vagrant-libvirt 0.9.0 → 0.10.0

data/locales/en.yml

@@ -16,7 +16,7 @@ en:
       Created volume larger than box defaults, will require manual resizing of
       filesystems to utilize.
     box_version_missing: |-
-      No verison detected for %{name}, using timestamp to watch for modifications. Consider
+      No version detected for %{name}, using timestamp to watch for modifications. Consider
       generating a local metadata for the box with a version to allow better handling.
       See https://www.vagrantup.com/docs/boxes/format#box-metadata for further details.
     uploading_volume: |-
@@ -25,6 +25,8 @@ en:
       Creating image (snapshot of base box volume).
     removing_domain_volume: |-
       Removing image (snapshot of base box volume).
+    updating_domain: |-
+      Updating domain definition due to configuration change
     starting_domain: |-
       Starting domain.
     terminating: |-
@@ -138,7 +140,7 @@ en:
         Error while creating a storage pool volume: %{error_message}
       fog_create_domain_volume_error: |-
         Error while creating volume for domain: %{error_message}
-      fog_create_server_error: |-
+      create_server_error: |-
         Error while creating domain: %{error_message}
       domain_name_exists: |-
         Name `%{domain_name}` of domain about to create is already taken. Please try to run
@@ -183,6 +185,16 @@ en:
       management_network_required: |-
         Management network can't be disabled when VM use box.
         Please fix your configuration and run vagrant again.
+      snapshot_deletion_error: |-
+        Error while deleting snapshot: %{error_message}.
+      snapshot_missing: |-
+        Snapshot not found: %{error_message}.
+      snapshot_list_error: |-
+        Cannot list snapshots: %{error_message}.
+      snapshot_creation_error: |-
+        Cannot create snapshot(s): %{error_message}.
+      snapshot_reversion_error: |-
+        Cannot revert snapshot(s): %{error_message}.
       serial_cannot_create_path_error: |-
         Error creating path for serial port output log: %{path}
 
@@ -202,3 +214,13 @@ en:
       preparing: |-
         The vagrant machine is being prepared for creation, please wait for
         it to reach a steady state before issuing commands on it.
+
+    cap:
+      virtiofs:
+        preparing: Configuring virtiofs devices for shared folders...
+        mounting: Mounting virtiofs shared folders...
+        cleanup: Removing virtiofs devices for shared folders...
+      9p:
+        preparing: Configuring 9p devices for shared folders...
+        mounting: Mounting 9p shared folders...
+        cleanup: Removing 9p devices for shared folders...

data/spec/acceptance/additional_storage_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'additional storage configured', acceptance: true do
+  include_context 'libvirt_acceptance'
+
+  before do
+    environment.skeleton('additional_storage')
+  end
+
+  after do
+    assert_execute('vagrant', 'destroy', '--force')
+  end
+
+  it 'should succeed' do
+    status('Test: machine is created successfully')
+    result = environment.execute('vagrant', 'up')
+    expect(result).to exit_with(0)
+
+    status('Test: additional storage configured')
+    expect(result.stdout).to match(/\(vda\).*work_default.img/)
+    expect(result.stdout).to match(/\(vdb\).*work_default-vdb\.qcow2/)
+
+    status('Test: reload handles additional storage correctly')
+    result = environment.execute('vagrant', 'reload')
+    expect(result).to exit_with(0)
+
+    status('Test: additional storage reported correctly')
+    expect(result.stdout).to match(/\(vdb\).*work_default-vdb\.qcow2/)
+  end
+end

data/spec/acceptance/package_domain_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'package domain', acceptance: true do
+  include_context 'libvirt_acceptance'
+
+  before(:all) do
+    expect(Vagrant::Util::Which.which('virt-sysprep')).to be_truthy,
+                                                          'packaging tests require virt-sysprep, please install'
+    expect(Vagrant::Util::Which.which('virt-sparsify')).to be_truthy,
+                                                           'packaging tests require virt-sparsify, please install'
+
+    result = (File.exist?('C:\\') ? `dir /-C #{Dir.tmpdir}` : `df #{Dir.tmpdir}`).split("\n").last
+    expect(result.split[3].to_i).to be > 6 * 1024 * 1024,
+                                    "packaging tests require more than 6GiB of space under #{Dir.tmpdir}"
+  end
+
+  after(:each) do
+    assert_execute('vagrant', 'destroy', '--force')
+  end
+
+  let(:testbox_envvars) { { VAGRANT_VAGRANTFILE: 'Vagrantfile.testbox' } }
+
+  context 'simple' do
+    before do
+      environment.skeleton('package_simple')
+    end
+
+    after do
+      result = environment.execute('vagrant', 'destroy', '--force', extra_env: testbox_envvars)
+      expect(result).to exit_with(0)
+
+      assert_execute('vagrant', 'box', 'remove', '--force', 'test-package-simple-domain')
+    end
+
+    it 'should succeed' do
+      status('Test: machine is created successfully')
+      expect(environment.execute('vagrant', 'up')).to exit_with(0)
+
+      status('Test: package machine successfully')
+      expect(environment.execute('vagrant', 'package')).to exit_with(0)
+
+      status('Test: add packaged box')
+      expect(environment.execute(
+        'vagrant', 'box', 'add', '--force', '--name', 'test-package-simple-domain', 'package.box'
+      )).to exit_with(0)
+
+      status('Test: machine from packaged box is created successfully')
+      result = environment.execute('vagrant', 'up', extra_env: testbox_envvars)
+      expect(result).to exit_with(0)
+      expect(result.stdout).to match(/test-package-complex-domain/)
+    end
+  end
+
+  context 'complex' do
+    before do
+      environment.skeleton('package_complex')
+      extra_env.merge!(
+        {
+          VAGRANT_LIBVIRT_VIRT_SYSPREP_OPERATIONS: 'defaults,-ssh-userdir,customize',
+          VAGRANT_LIBVIRT_VIRT_SYSPREP_OPTIONS: '--run $(pwd)/scripts/sysprep.sh',
+        }
+      )
+    end
+
+    after do
+      expect(environment.execute('vagrant', 'destroy', '--force', extra_env: testbox_envvars)).to exit_with(0)
+      assert_execute('vagrant', 'box', 'remove', '--force', 'test-package-complex-domain')
+    end
+
+    it 'should succeed' do
+      status('Test: machine is created successfully')
+      expect(environment.execute('vagrant', 'up')).to exit_with(0)
+
+      status('Test: package machine successfully')
+      expect(environment.execute('vagrant', 'package')).to exit_with(0)
+
+      status('Test: add packaged box')
+      expect(environment.execute(
+        'vagrant', 'box', 'add', '--force', '--name', 'test-package-complex-domain', 'package.box'
+      )).to exit_with(0)
+
+      status('Test: machine from packaged box is created successfully')
+      result = environment.execute('vagrant', 'up', extra_env: testbox_envvars)
+      expect(result).to exit_with(0)
+      expect(result.stdout).to match(/test-package-complex-domain/)
+    end
+  end
+end

data/spec/acceptance/provider_settings_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'provider settings', acceptance: true do
+  include_context 'libvirt_acceptance'
+
+  after do
+    assert_execute('vagrant', 'destroy', '--force')
+  end
+
+  context 'with defaults' do
+    before do
+      environment.skeleton('default_settings')
+    end
+
+    it 'should succeed' do
+      status('Test: machine is created successfully')
+      result = environment.execute('vagrant', 'up')
+      expect(result).to exit_with(0)
+
+      status('Test: CPU matches default')
+      expect(result.stdout).to match(/Cpus:\s+1$/)
+
+      status('Test: memory matches default')
+      expect(result.stdout).to match(/Memory:\s+512M/)
+
+      status('Test: default prefix is used')
+      expect(result.stdout).to match(/Name:\s+work_default$/)
+    end
+  end
+
+  context 'with modified config' do
+    before do
+      environment.skeleton('adjusted_settings')
+    end
+
+    it 'should succeed' do
+      status('Test: machine is created successfully')
+      result = environment.execute('vagrant', 'up')
+      expect(result).to exit_with(0)
+
+      status('Test: CPUs are changed')
+      expect(result.stdout).to match(/Cpus:\s+2$/)
+
+      status('Test: memory is changed')
+      expect(result.stdout).to match(/Memory:\s+1000M$/)
+
+      status('Test: default prefix is changed')
+      expect(result.stdout).to match(/Name:\s+changed_default_prefixdefault$/)
+      expect(result.stdout).to match(/\(vda\).*changed_default_prefixdefault\.img/)
+    end
+  end
+end

data/spec/acceptance/simple_vm_provision_via_shell_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'simple vm provision via shell', acceptance: true do
+  include_context 'libvirt_acceptance'
+
+  before do
+    environment.skeleton('simple_vm_provision')
+  end
+
+  after do
+    assert_execute('vagrant', 'destroy', '--force')
+  end
+
+  it 'should succeed' do
+    status('Test: machine is created successfully')
+    result = environment.execute('vagrant', 'up')
+    expect(result).to exit_with(0)
+
+    status('Test: provision script executed')
+    expect(result.stdout).to match(/Hello, World/)
+
+    status('Test: reload')
+    result = environment.execute('vagrant', 'reload')
+    expect(result).to exit_with(0)
+
+    status('Test: provision checked if already executed')
+    expect(result.stdout).to match(/Machine already provisioned/)
+  end
+end

data/spec/acceptance/snapshots_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'snapshots', acceptance: true do
+  include_context 'libvirt_acceptance'
+
+  after(:each) do
+    assert_execute('vagrant', 'destroy', '--force')
+  end
+
+  before do
+    environment.skeleton('snapshots')
+  end
+
+  it 'should succeed' do
+    status('Test: machine is created successfully')
+    expect(environment.execute('vagrant', 'up')).to exit_with(0)
+
+    status('Test: add test file')
+    expect(environment.execute('vagrant', 'ssh', '--', '-t', 'touch a.txt')).to exit_with(0)
+
+    status('Test: create snapshot')
+    expect(environment.execute('vagrant', 'snapshot', 'save', 'default', 'test')).to exit_with(0)
+
+    status('Test: modify files')
+    expect(environment.execute('vagrant', 'ssh', '--', '-t', 'rm a.txt')).to exit_with(0)
+    expect(environment.execute('vagrant', 'ssh', '--', '-t', 'ls a.txt')).to exit_with(1)
+    expect(environment.execute('vagrant', 'ssh', '--', '-t', 'touch b.txt')).to exit_with(0)
+
+    status('Test: restore snapshot')
+    expect(environment.execute('vagrant', 'snapshot', 'restore', 'test')).to exit_with(0)
+
+    status('Test: files are as expected')
+    expect(environment.execute('vagrant', 'ssh', '--', '-t', 'ls a.txt')).to exit_with(0)
+    expect(environment.execute('vagrant', 'ssh', '--', '-t', 'ls b.txt')).to exit_with(1)
+
+    status('Test: snapshot removal works')
+    expect(environment.execute('vagrant', 'snapshot', 'delete', 'test')).to exit_with(0)
+  end
+end

data/spec/acceptance/support-skeletons/package_complex/Vagrantfile.testbox

@@ -0,0 +1,14 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "test-package-complex-domain"
+  config.vm.define 'package-complex'
+  config.vm.synced_folder ".", "/vagrant", disabled: true
+
+  config.vm.provider :libvirt do |libvirt|
+    libvirt.driver = "qemu"
+    libvirt.cpus = 2
+    libvirt.memory = 2048
+  end
+end

data/spec/acceptance/support-skeletons/package_complex/scripts/sysprep.sh

@@ -0,0 +1,32 @@
+#!/bin/sh -eux
+
+# consider purging any packages you don't need here
+
+echo "autoremoving packages and cleaning apt data"
+apt-get -y autoremove;
+apt-get -y clean;
+
+# repeat what machine-ids does in sysprep as this script needs to run via customize
+# which has a bug resulting in the machine-ids being regenerated
+
+if [ -f /etc/machine-id ]
+then
+    truncate --size=0 /etc/machine-id
+fi
+
+if [ -f /var/lib/dbus/machine-id ]
+then
+    truncate --size=0 /run/machine-id
+fi
+
+echo "remove /var/cache"
+find /var/cache -type f -exec rm -rf {} \;
+
+echo "force a new random seed to be generated"
+rm -f /var/lib/systemd/random-seed
+
+# for debian based systems ensure host keys regenerated on boot
+if [ -e /usr/sbin/dpkg-reconfigure ]
+then
+    printf "@reboot root command bash -c 'export PATH=$PATH:/usr/sbin ; export DEBIAN_FRONTEND=noninteractive ; export DEBCONF_NONINTERACTIVE_SEEN=true ; /usr/sbin/dpkg-reconfigure openssh-server &>/dev/null ; /bin/systemctl restart ssh.service ; rm --force /etc/cron.d/keys'\n" > /etc/cron.d/keys
+fi

data/spec/acceptance/support-skeletons/package_simple/Vagrantfile.testbox

@@ -0,0 +1,10 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "test-package-simple-domain"
+  config.vm.define 'package-simple'
+  config.ssh.shell = "/bin/sh"
+  config.ssh.insert_key = false
+  config.vm.synced_folder ".", "/vagrant", disabled: true
+end

data/spec/acceptance/two_disks_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'handle two disk machine', acceptance: true do
+  include_context 'libvirt_acceptance'
+
+  after do
+    assert_execute('vagrant', 'destroy', '--force')
+  end
+
+  before do
+    environment.skeleton('two_disks')
+    environment.execute(File.expand_path('../../tools/create_box_with_two_disks.sh', __dir__),
+                        environment.homedir.to_s, 'vagrant')
+  end
+
+  it 'should succeed' do
+    status('Test: machine is created successfully')
+    result = environment.execute('vagrant', 'up')
+    expect(result).to exit_with(0)
+
+    status('Test: disk one referenced')
+    expect(result.stdout).to match(/Image\(vda\):.*work_default.img, virtio, 2G/)
+
+    status('Test: disk two referenced')
+    expect(result.stdout).to match(/Image\(vdb\):.*work_default_1.img, virtio, 10G/)
+  end
+end

data/spec/acceptance/use_qemu_agent_for_connectivity_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'use qemu agent to determine machine private address', acceptance: true do
+  include_context 'libvirt_acceptance'
+
+  before do
+    environment.skeleton('qemu_agent')
+  end
+
+  after do
+    assert_execute('vagrant', 'destroy', '--force')
+  end
+
+  it 'should succeed' do
+    status('Test: machine is created successfully')
+    result = environment.execute('vagrant', 'up')
+    expect(result).to exit_with(0)
+
+    # extract SSH IP address emitted as it should be the private network since
+    # the mgmt network has not been attached
+    hostname = result.stdout.each_line.find { |line| line.include?('SSH address:') }
+    expect(hostname).to_not be_nil
+    ip_address = hostname.strip.split.last.split(':').first
+    # default private network for vagrant-libvirt unless explicitly configured
+    expect(IPAddr.new('172.28.128.0/255.255.255.0')).to include(IPAddr.new(ip_address))
+
+    # ssh'ing successfully means that the private network is accessible
+    status('Test: machine private network is accessible')
+    result = environment.execute('vagrant', 'ssh', '-c', 'echo "hello, world"')
+    expect(result).to exit_with(0)
+    expect(result.stdout).to match(/hello, world/)
+  end
+end

data/spec/spec_helper.rb

@@ -55,4 +55,7 @@ RSpec.configure do |config|
   config.mock_with :rspec do |mocks|
     mocks.verify_partial_doubles = true
   end
+
+  # don't run acceptance tests by default
+  config.filter_run_excluding :acceptance => true
 end

data/spec/support/acceptance/configuration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'vagrant-spec/acceptance/configuration'
+
+module VagrantPlugins
+  module VagrantLibvirt
+    module Spec
+      module Acceptance
+        class Configuration < Vagrant::Spec::Acceptance::Configuration
+          attr_accessor :clean_on_fail
+
+          def initialize
+            super
+
+            @clean_on_fail = true
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/acceptance/context.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'vagrant-spec/acceptance/configuration'
+require "vagrant-spec/acceptance/rspec/matcher_exit_with"
+
+require_relative 'isolated_environment'
+
+shared_context "acceptance" do
+  # Setup the environment so that we have an isolated area
+  # to run Vagrant. We do some configuration here as well in order
+  # to replace "vagrant" with the proper path to Vagrant as well
+  # as tell the isolated environment about custom environmental
+  # variables to pass in.
+  let!(:environment) { new_environment }
+
+  let(:config) { Vagrant::Spec::Acceptance::Configuration.new }
+
+  let(:extra_env) { {} }
+
+  # The skeleton paths that will be used to configure environments.
+  let(:skeleton_paths) do
+    root = Vagrant::Spec.source_root.join("acceptance", "support-skeletons")
+    config.skeleton_paths.dup.unshift(root)
+  end
+
+  after(:each) do |example|
+    if example.exception.nil? || config.clean_on_fail
+      environment.close
+    else
+      example.reporter.message("Temporary work and home dirs (#{environment.workdir} and #{environment.homedir}) not removed to allow debug")
+    end
+  end
+
+  # Creates a new isolated environment instance each time it is called.
+  #
+  # @return [Acceptance::IsolatedEnvironment]
+  def new_environment(env=nil)
+    apps = { "vagrant" => config.vagrant_path }
+    env  = config.env.merge(env || {})
+    env.merge!(extra_env)
+
+    VagrantPlugins::VagrantLibvirt::Spec::AcceptanceIsolatedEnvironment.new(
+      apps: apps,
+      env: env,
+      skeleton_paths: skeleton_paths,
+    )
+  end
+
+  # Executes the given command in the context of the isolated environment.
+  #
+  # @return [Object]
+  def execute(*args, env: nil, log: true, &block)
+    env ||= environment
+    status("Execute: #{args.join(" ")}") if log
+    env.execute(*args, &block)
+  end
+
+  # This method is an assertion helper for asserting that a process
+  # succeeds. It is a wrapper around `execute` that asserts that the
+  # exit status was successful.
+  def assert_execute(*args, env: nil, &block)
+    result = execute(*args, env: env, &block)
+    expect(result).to exit_with(0)
+    result
+  end
+
+  def status(message)
+    RSpec.world.reporter.message(message)
+  end
+end

data/spec/support/acceptance/isolated_environment.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'vagrant-spec/acceptance/isolated_environment'
+require 'vagrant-spec/subprocess'
+require 'vagrant-spec/which'
+
+module VagrantPlugins
+  module VagrantLibvirt
+    module Spec
+      class AcceptanceIsolatedEnvironment < Vagrant::Spec::AcceptanceIsolatedEnvironment
+        # Executes a command in the context of this isolated environment.
+        # Any command executed will therefore see our temporary directory
+        # as the home directory.
+        #
+        # If the command has been defined with a special path, then the
+        # command will be replaced with the full path to that command.
+        def execute(command, *args, **options)
+          # Create the command
+          command = replace_command(command)
+          # Use provided command if it is a valid executable
+          if !File.executable?(command)
+            # If it's not a valid executable, search for vagrant
+            command = Vagrant::Spec::Which.which(command)
+          end
+
+          # Build up the options
+          options[:env] = @env.merge(options.delete(:extra_env) || {})
+          options[:notify] = [:stdin, :stderr, :stdout]
+          options[:workdir] = @workdir.to_s
+
+          # Execute, logging out the stdout/stderr as we get it
+          @logger.info("Executing: #{[command].concat(args).inspect}")
+          Vagrant::Spec::Subprocess.execute(command, *args, **options) do |type, data|
+            @logger.debug("#{type}: #{data}") if type == :stdout || type == :stderr
+            yield type, data if block_given?
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/libvirt_acceptance_context.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'acceptance/context'
+
+FALSEY_VALUES = %w[f false no n 0].freeze
+
+shared_context 'libvirt_acceptance' do
+  include_context 'acceptance'
+
+  # The skeleton paths that will be used to configure environments.
+  let(:skeleton_paths) do
+    root = File.expand_path('../acceptance/support-skeletons', __dir__)
+    config.skeleton_paths.dup.unshift(root)
+  end
+
+  let(:config) do
+    c = VagrantPlugins::VagrantLibvirt::Spec::Acceptance::Configuration.new
+    c.clean_on_fail = FALSEY_VALUES.include?(ENV.fetch('VAGRANT_SPEC_SKIP_CLEANUP', 'false').to_s.downcase)
+
+    c
+  end
+
+  before(:each) do
+    # allow execution environment to cache boxes used
+    symlink_boxes(ENV.fetch('VAGRANT_HOME', nil), environment)
+  end
+
+  after(:each) do
+    # ensure we remove the symlink
+    boxes_symlink = File.join(environment.homedir, 'boxes')
+    File.delete(boxes_symlink) if File.symlink?(boxes_symlink)
+  end
+
+  around do |example|
+    vagrant_cwd = ENV.delete('VAGRANT_CWD')
+    env_provider_before = ENV.fetch('VAGRANT_DEFAULT_PROVIDER', nil)
+    ENV['VAGRANT_DEFAULT_PROVIDER'] = 'libvirt'
+
+    begin
+      example.run
+    ensure
+      ENV['VAGRANT_CWD'] = vagrant_cwd if vagrant_cwd
+      if env_provider_before.nil?
+        ENV.delete('VAGRANT_DEFAULT_PROVIDER')
+      else
+        ENV['VAGRANT_DEFAULT_PROVIDER'] = env_provider_before
+      end
+    end
+  end
+
+  def duplicate_environment(env, *args)
+    dup_env = new_environment(*args)
+    symlink_boxes(env.homedir, dup_env)
+
+    dup_env
+  end
+
+  def symlink_boxes(vagrant_home, target_env)
+    return if vagrant_home.nil?
+
+    # allow use the same boxes location as source environment
+    File.symlink File.realpath(File.join(vagrant_home, 'boxes')), File.join(target_env.homedir, 'boxes')
+  end
+end

data/spec/support/sharedcontext.rb

@@ -37,5 +37,6 @@ shared_context 'unit' do
   before (:each) do
     allow(machine).to receive(:guest).and_return(guest)
     allow(machine).to receive(:communicate).and_return(communicator)
+    allow(machine).to receive(:ui).and_return(ui)
   end
 end