vagrant-libvirt 0.0.40 → 0.0.41

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

@@ -1,40 +0,0 @@
-require 'log4r'
-
-module VagrantPlugins
-  module ProviderLibvirt
-    module Action
-      # Suspend domain.
-      class SuspendDomain
-        def initialize(app, _env)
-          @logger = Log4r::Logger.new('vagrant_libvirt::action::suspend_domain')
-          @app = app
-        end
-
-        # make pause
-        def call(env)
-          env[:ui].info(I18n.t('vagrant_libvirt.suspending_domain'))
-
-          domain = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
-          raise Errors::NoDomainError if domain.nil?
-
-          config = env[:machine].provider_config
-          if config.suspend_mode == 'managedsave'
-            libvirt_domain = env[:machine].provider.driver.connection.client.lookup_domain_by_uuid(env[:machine].id)
-            begin
-              libvirt_domain.managed_save
-            rescue => e
-              env[:ui].error("Error doing a managed save for domain. It may have entered a paused state.
-                Check the output of `virsh managedsave DOMAIN_NAME --verbose` on the VM host, error: #{e.message}")
-            end
-          else
-            domain.suspend
-          end
-
-          @logger.info("Machine #{env[:machine].id} is suspended ")
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-require 'log4r'
-require 'vagrant-libvirt/errors'
-require 'vagrant-libvirt/util/timer'
-require 'vagrant/util/retryable'
-
-module VagrantPlugins
-  module ProviderLibvirt
-    module Action
-      # Wait till domain is started, till it obtains an IP address and is
-      # accessible via ssh.
-      class WaitTillUp
-        include Vagrant::Util::Retryable
-
-        def initialize(app, _env)
-          @logger = Log4r::Logger.new('vagrant_libvirt::action::wait_till_up')
-          @app = app
-        end
-
-        def call(env)
-          # Initialize metrics if they haven't been
-          env[:metrics] ||= {}
-
-          # Get domain object
-          domain = env[:machine].provider.driver.get_domain(env[:machine].id.to_s)
-          if domain.nil?
-            raise Errors::NoDomainError,
-                  error_message: "Domain #{env[:machine].id} not found"
-          end
-
-          # Wait for domain to obtain an ip address. Ip address is searched
-          # from arp table, either localy or remotely via ssh, if libvirt
-          # connection was done via ssh.
-          env[:ip_address] = nil
-          env[:metrics]['instance_ip_time'] = Util::Timer.time do
-            @logger.debug("Searching for IP for MAC address: #{domain.mac}")
-            env[:ui].info(I18n.t('vagrant_libvirt.waiting_for_ip'))
-            retryable(on: Fog::Errors::TimeoutError, tries: 300) do
-              # If we're interrupted don't worry about waiting
-              return terminate(env) if env[:interrupted]
-
-              # Wait for domain to obtain an ip address
-              domain.wait_for(2) do
-                addresses.each_pair do |_type, ip|
-                  env[:ip_address] = ip[0] unless ip[0].nil?
-                end
-                !env[:ip_address].nil?
-              end
-            end
-          end
-          @logger.info("Got IP address #{env[:ip_address]}")
-          @logger.info("Time for getting IP: #{env[:metrics]['instance_ip_time']}")
-
-          # Machine has ip address assigned, now wait till we are able to
-          # connect via ssh.
-          env[:metrics]['instance_ssh_time'] = Util::Timer.time do
-            env[:ui].info(I18n.t('vagrant_libvirt.waiting_for_ssh'))
-            retryable(on: Fog::Errors::TimeoutError, tries: 60) do
-              # If we're interrupted don't worry about waiting
-              next if env[:interrupted]
-
-              # Wait till we are able to connect via ssh.
-              loop do
-                # If we're interrupted then just back out
-                break if env[:interrupted]
-                break if env[:machine].communicate.ready?
-                sleep 2
-              end
-            end
-          end
-          # if interrupted above, just terminate immediately
-          return terminate(env) if env[:interrupted]
-          @logger.info("Time for SSH ready: #{env[:metrics]['instance_ssh_time']}")
-
-          # Booted and ready for use.
-          # env[:ui].info(I18n.t("vagrant_libvirt.ready"))
-
-          @app.call(env)
-        end
-
-        def recover(env)
-          return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
-
-          # Undo the import
-          terminate(env)
-        end
-
-        def terminate(env)
-          if env[:machine].provider.state.id != :not_created
-            # If we're not supposed to destroy on error then just return
-            return unless env[:destroy_on_error]
-
-            destroy_env = env.dup
-            destroy_env.delete(:interrupted)
-            destroy_env[:config_validate] = false
-            destroy_env[:force_confirm_destroy] = true
-            env[:action_runner].run(Action.action_destroy, destroy_env)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-libvirt/cap/mount_p9.rb

@@ -1,42 +0,0 @@
-require 'digest/md5'
-require 'vagrant/util/retryable'
-
-module VagrantPlugins
-  module ProviderLibvirt
-    module Cap
-      class MountP9
-        extend Vagrant::Util::Retryable
-
-        def self.mount_p9_shared_folder(machine, folders)
-          folders.each do |_name, opts|
-            # Expand the guest path so we can handle things like "~/vagrant"
-            expanded_guest_path = machine.guest.capability(
-              :shell_expand_guest_path, opts[:guestpath]
-            )
-
-            # Do the actual creating and mounting
-            machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
-
-            # Mount
-            mount_tag = Digest::MD5.new.update(opts[:hostpath]).to_s[0, 31]
-
-            mount_opts = '-o trans=virtio'
-            mount_opts += ",access=#{opts[:owner]}" if opts[:owner]
-            mount_opts += ",version=#{opts[:version]}" if opts[:version]
-            mount_opts += ",#{opts[:mount_opts]}" if opts[:mount_opts]
-
-            mount_command = "mount -t 9p #{mount_opts} '#{mount_tag}' #{expanded_guest_path}"
-            retryable(on: Vagrant::Errors::LinuxMountFailed,
-                      tries: 5,
-                      sleep: 3) do
-              machine.communicate.sudo('modprobe 9p')
-              machine.communicate.sudo('modprobe 9pnet_virtio')
-              machine.communicate.sudo(mount_command,
-                                       error_class: Vagrant::Errors::LinuxMountFailed)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-libvirt/cap/nic_mac_addresses.rb

@@ -1,17 +0,0 @@
-module VagrantPlugins
-  module ProviderLibvirt
-    module Cap
-      class NicMacAddresses
-        def self.nic_mac_addresses(machine)
-          # Vagrant expects a Hash with an index starting at 1 as key
-          # and the mac as uppercase string without colons as value
-          nic_macs = {}
-          machine.provider.mac_addresses.each do |index, mac|
-            nic_macs[index + 1] = mac.upcase.delete(':')
-          end
-          nic_macs
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-libvirt/cap/synced_folder.rb

@@ -1,113 +0,0 @@
-require 'log4r'
-require 'ostruct'
-require 'nokogiri'
-require 'digest/md5'
-
-require 'vagrant/util/subprocess'
-require 'vagrant/errors'
-require 'vagrant-libvirt/errors'
-# require_relative "helper"
-
-module VagrantPlugins
-  module SyncedFolder9p
-    class SyncedFolder < Vagrant.plugin('2', :synced_folder)
-      include Vagrant::Util
-      include VagrantPlugins::ProviderLibvirt::Util::ErbTemplate
-
-      def initialize(*args)
-        super
-        @logger = Log4r::Logger.new('vagrant_libvirt::synced_folders::9p')
-      end
-
-      def usable?(machine, _raise_error = false)
-        # bail now if not using libvirt since checking version would throw error
-        return false unless machine.provider_name == :libvirt
-
-        # <filesystem/> support in device attach/detach introduced in 1.2.2
-        # version number format is major * 1,000,000 + minor * 1,000 + release
-        libvirt_version = machine.provider.driver.connection.client.libversion
-        libvirt_version >= 1_002_002
-      end
-
-      def prepare(machine, folders, _opts)
-        raise Vagrant::Errors::Error('No libvirt connection') if machine.provider.driver.connection.nil?
-        @conn = machine.provider.driver.connection.client
-
-        begin
-          # loop through folders
-          folders.each do |id, folder_opts|
-            folder_opts.merge!(target: id,
-                               accessmode: 'passthrough',
-                               mount: true,
-                               readonly: nil) { |_k, ov, _nv| ov }
-
-            mount_tag = Digest::MD5.new.update(folder_opts[:hostpath]).to_s[0, 31]
-            folder_opts[:mount_tag] = mount_tag
-
-            machine.ui.info "================\nMachine id: #{machine.id}\nShould be mounting folders\n #{id}, opts: #{folder_opts}"
-
-            #xml = to_xml('filesystem', folder_opts)
-            xml = Nokogiri::XML::Builder.new do |xml|
-              xml.filesystem(type: 'mount', accessmode: folder_opts[:accessmode]) do
-                xml.driver(type: 'path', wrpolicy: 'immediate')
-                xml.source(dir: folder_opts[:hostpath])
-                xml.target(dir: mount_tag)
-                xml.readonly unless folder_opts[:readonly].nil?
-              end
-            end.to_xml(
-              save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION |
-                         Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
-                         Nokogiri::XML::Node::SaveOptions::FORMAT
-            )
-            # puts "<<<<< XML:\n #{xml}\n >>>>>"
-            @conn.lookup_domain_by_uuid(machine.id).attach_device(xml, 0)
-          end
-        rescue => e
-          machine.ui.error("could not attach device because: #{e}")
-          raise VagrantPlugins::ProviderLibvirt::Errors::AttachDeviceError,
-                error_message: e.message
-        end
-      end
-
-      # TODO: once up, mount folders
-      def enable(machine, folders, _opts)
-        # Go through each folder and mount
-        machine.ui.info('mounting p9 share in guest')
-        # Only mount folders that have a guest path specified.
-        mount_folders = {}
-        folders.each do |id, opts|
-          next unless opts[:mount] && opts[:guestpath] && !opts[:guestpath].empty?
-          mount_folders[id] = opts.dup
-          # merge common options if not given
-          mount_folders[id].merge!(version: '9p2000.L') { |_k, ov, _nv| ov }
-        end
-        # Mount the actual folder
-        machine.guest.capability(
-          :mount_p9_shared_folder, mount_folders
-        )
-      end
-
-      def cleanup(machine, _opts)
-        if machine.provider.driver.connection.nil?
-          raise Vagrant::Errors::Error('No libvirt connection')
-        end
-        @conn = machine.provider.driver.connection.client
-        begin
-          if machine.id && machine.id != ''
-            dom = @conn.lookup_domain_by_uuid(machine.id)
-            Nokogiri::XML(dom.xml_desc).xpath(
-              '/domain/devices/filesystem'
-            ).each do |xml|
-              dom.detach_device(xml.to_s)
-              machine.ui.info 'Cleaned up shared folders'
-            end
-          end
-        rescue => e
-          machine.ui.error("could not detach device because: #{e}")
-          raise VagrantPlugins::ProviderLibvirt::Errors::DetachDeviceError,
-                error_message: e.message
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-libvirt/config.rb

@@ -1,698 +0,0 @@
-require 'vagrant'
-
-class Numeric
-  Alphabet = ('a'..'z').to_a
-  def vdev
-    s = ''
-    q = self
-    (q, r = (q - 1).divmod(26)) && s.prepend(Alphabet[r]) until q.zero?
-    'vd' + s
-  end
-end
-
-module VagrantPlugins
-  module ProviderLibvirt
-    class Config < Vagrant.plugin('2', :config)
-      # manually specify URI
-      # will supercede most other options if provided
-      attr_accessor :uri
-
-      # A hypervisor name to access via Libvirt.
-      attr_accessor :driver
-
-      # The name of the server, where libvirtd is running.
-      attr_accessor :host
-
-      # If use ssh tunnel to connect to Libvirt.
-      attr_accessor :connect_via_ssh
-      # Path towards the libvirt socket
-      attr_accessor :socket
-
-      # The username to access Libvirt.
-      attr_accessor :username
-
-      # Password for Libvirt connection.
-      attr_accessor :password
-
-      # ID SSH key file
-      attr_accessor :id_ssh_key_file
-
-      # Libvirt storage pool name, where box image and instance snapshots will
-      # be stored.
-      attr_accessor :storage_pool_name
-
-      # Turn on to prevent hostname conflicts
-      attr_accessor :random_hostname
-
-      # Libvirt default network
-      attr_accessor :management_network_name
-      attr_accessor :management_network_address
-      attr_accessor :management_network_mode
-      attr_accessor :management_network_mac
-      attr_accessor :management_network_guest_ipv6
-      attr_accessor :management_network_autostart
-
-      # Default host prefix (alternative to use project folder name)
-      attr_accessor :default_prefix
-
-      # Domain specific settings used while creating new domain.
-      attr_accessor :uuid
-      attr_accessor :memory
-      attr_accessor :channel
-      attr_accessor :cpus
-      attr_accessor :cpu_mode
-      attr_accessor :cpu_model
-      attr_accessor :cpu_fallback
-      attr_accessor :cpu_features
-      attr_accessor :features
-      attr_accessor :numa_nodes
-      attr_accessor :loader
-      attr_accessor :boot_order
-      attr_accessor :machine_type
-      attr_accessor :machine_arch
-      attr_accessor :machine_virtual_size
-      attr_accessor :disk_bus
-      attr_accessor :disk_device
-      attr_accessor :nic_model_type
-      attr_accessor :nested
-      attr_accessor :volume_cache
-      attr_accessor :kernel
-      attr_accessor :cmd_line
-      attr_accessor :initrd
-      attr_accessor :dtb
-      attr_accessor :emulator_path
-      attr_accessor :graphics_type
-      attr_accessor :graphics_autoport
-      attr_accessor :graphics_port
-      attr_accessor :graphics_passwd
-      attr_accessor :graphics_ip
-      attr_accessor :video_type
-      attr_accessor :video_vram
-      attr_accessor :keymap
-      attr_accessor :kvm_hidden
-      attr_accessor :sound_type
-
-      # Sets the information for connecting to a host TPM device
-      # Only supports socket-based TPMs
-      attr_accessor :tpm_model
-      attr_accessor :tpm_type
-      attr_accessor :tpm_path
-
-      # Sets the max number of NICs that can be created
-      # Default set to 8. Don't change the default unless you know
-      # what are doing
-      attr_accessor :nic_adapter_count
-
-      # Storage
-      attr_accessor :disks
-      attr_accessor :cdroms
-
-      # Inputs
-      attr_accessor :inputs
-
-      # Channels
-      attr_accessor :channels
-
-      # PCI device passthrough
-      attr_accessor :pcis
-
-      # Random number device passthrough
-      attr_accessor :rng
-
-      # Watchdog device
-      attr_accessor :watchdog_dev
-
-      # USB device passthrough
-      attr_accessor :usbs
-
-      # Redirected devices
-      attr_accessor :redirdevs
-      attr_accessor :redirfilters
-
-      # smartcard device
-      attr_accessor :smartcard_dev
-
-      # Suspend mode
-      attr_accessor :suspend_mode
-
-      # Autostart
-      attr_accessor :autostart
-
-      # Attach mgmt network
-      attr_accessor :mgmt_attach
-
-      # Additional qemuargs arguments
-      attr_accessor :qemu_args
-
-      def initialize
-        @uri               = UNSET_VALUE
-        @driver            = UNSET_VALUE
-        @host              = UNSET_VALUE
-        @connect_via_ssh   = UNSET_VALUE
-        @username          = UNSET_VALUE
-        @password          = UNSET_VALUE
-        @id_ssh_key_file   = UNSET_VALUE
-        @storage_pool_name = UNSET_VALUE
-        @random_hostname   = UNSET_VALUE
-        @management_network_name    = UNSET_VALUE
-        @management_network_address = UNSET_VALUE
-        @management_network_mode = UNSET_VALUE
-        @management_network_mac  = UNSET_VALUE
-        @management_network_guest_ipv6 = UNSET_VALUE
-        @management_network_autostart = UNSET_VALUE
-
-        # Domain specific settings.
-        @uuid              = UNSET_VALUE
-        @memory            = UNSET_VALUE
-        @cpus              = UNSET_VALUE
-        @cpu_mode          = UNSET_VALUE
-        @cpu_model         = UNSET_VALUE
-        @cpu_fallback      = UNSET_VALUE
-        @cpu_features      = UNSET_VALUE
-        @features          = UNSET_VALUE
-        @numa_nodes        = UNSET_VALUE
-        @loader            = UNSET_VALUE
-        @machine_type      = UNSET_VALUE
-        @machine_arch      = UNSET_VALUE
-        @machine_virtual_size = UNSET_VALUE
-        @disk_bus          = UNSET_VALUE
-        @disk_device       = UNSET_VALUE
-        @nic_model_type    = UNSET_VALUE
-        @nested            = UNSET_VALUE
-        @volume_cache      = UNSET_VALUE
-        @kernel            = UNSET_VALUE
-        @initrd            = UNSET_VALUE
-        @dtb               = UNSET_VALUE
-        @cmd_line          = UNSET_VALUE
-        @emulator_path     = UNSET_VALUE
-        @graphics_type     = UNSET_VALUE
-        @graphics_autoport = UNSET_VALUE
-        @graphics_port     = UNSET_VALUE
-        @graphics_ip       = UNSET_VALUE
-        @graphics_passwd   = UNSET_VALUE
-        @video_type        = UNSET_VALUE
-        @video_vram        = UNSET_VALUE
-        @sound_type        = UNSET_VALUE
-        @keymap            = UNSET_VALUE
-        @kvm_hidden        = UNSET_VALUE
-
-        @tpm_model         = UNSET_VALUE
-        @tpm_type          = UNSET_VALUE
-        @tpm_path          = UNSET_VALUE
-
-        @nic_adapter_count = UNSET_VALUE
-
-        # Boot order
-        @boot_order        = []
-        # Storage
-        @disks             = []
-        @cdroms            = []
-
-        # Inputs
-        @inputs            = UNSET_VALUE
-
-        # Channels
-        @channels          = UNSET_VALUE
-
-        # PCI device passthrough
-        @pcis              = UNSET_VALUE
-
-        # Random number device passthrough
-        @rng = UNSET_VALUE
-
-        # Watchdog device
-        @watchdog_dev      = UNSET_VALUE
-
-        # USB device passthrough
-        @usbs              = UNSET_VALUE
-
-        # Redirected devices
-        @redirdevs         = UNSET_VALUE
-        @redirfilters      = UNSET_VALUE
-
-        # smartcard device
-        @smartcard_dev     = UNSET_VALUE
-
-        # Suspend mode
-        @suspend_mode      = UNSET_VALUE
-
-        # Autostart
-        @autostart         = UNSET_VALUE
-
-        # Attach mgmt network
-        @mgmt_attach       = UNSET_VALUE
-
-        @qemu_args  = []
-      end
-
-      def boot(device)
-        @boot_order << device # append
-      end
-
-      def _get_device(disks)
-        # skip existing devices and also the first one (vda)
-        exist = disks.collect { |x| x[:device] } + [1.vdev.to_s]
-        skip = 1 # we're 1 based, not 0 based...
-        loop do
-          dev = skip.vdev # get lettered device
-          return dev unless exist.include?(dev)
-          skip += 1
-        end
-      end
-
-      def _get_cdrom_dev(cdroms)
-        exist = Hash[cdroms.collect { |x| [x[:dev], true] }]
-        # hda - hdc
-        curr = 'a'.ord
-        while curr <= 'd'.ord
-          dev = 'hd' + curr.chr
-          if exist[dev]
-            curr += 1
-            next
-          else
-            return dev
-          end
-        end
-
-        # is it better to raise our own error, or let libvirt cause the exception?
-        raise 'Only four cdroms may be attached at a time'
-      end
-
-      def _generate_numa
-        raise 'NUMA nodes must be a factor of CPUs' if @cpus % @numa_nodes != 0
-
-        if @memory % @numa_nodes != 0
-          raise 'NUMA nodes must be a factor of memory'
-        end
-
-        numa = []
-
-        (1..@numa_nodes).each do |node|
-          numa_cpu_start = (@cpus / @numa_nodes) * (node - 1)
-          numa_cpu_end = (@cpus / @numa_nodes) * node - 1
-          numa_cpu = Array(numa_cpu_start..numa_cpu_end).join(',')
-          numa_mem = @memory / @numa_nodes
-
-          numa.push(id: node,
-                    cpu: numa_cpu,
-                    mem: numa_mem)
-        end
-
-        @numa_nodes = numa
-      end
-
-      def cpu_feature(options = {})
-        if options[:name].nil? || options[:policy].nil?
-          raise 'CPU Feature name AND policy must be specified'
-        end
-
-        @cpu_features = [] if @cpu_features == UNSET_VALUE
-
-        @cpu_features.push(name:   options[:name],
-                           policy: options[:policy])
-      end
-
-      def input(options = {})
-        if options[:type].nil? || options[:bus].nil?
-          raise 'Input type AND bus must be specified'
-        end
-
-        @inputs = [] if @inputs == UNSET_VALUE
-
-        @inputs.push(type: options[:type],
-                     bus:  options[:bus])
-      end
-
-      def channel(options = {})
-        if options[:type].nil?
-          raise 'Channel type must be specified.'
-        elsif options[:type] == 'unix' && options[:target_type] == 'guestfwd'
-          # Guest forwarding requires a target (ip address) and a port
-          if options[:target_address].nil? || options[:target_port].nil? ||
-             options[:source_path].nil?
-            raise 'guestfwd requires target_address, target_port and source_path'
-          end
-        end
-
-        @channels = [] if @channels == UNSET_VALUE
-
-        @channels.push(type: options[:type],
-                       source_mode: options[:source_mode],
-                       source_path: options[:source_path],
-                       target_address: options[:target_address],
-                       target_name: options[:target_name],
-                       target_port: options[:target_port],
-                       target_type: options[:target_type])
-      end
-
-      def random(options = {})
-        if !options[:model].nil? && options[:model] != 'random'
-          raise 'The only supported rng backend is "random".'
-        end
-
-        @rng = {} if @rng == UNSET_VALUE
-
-        @rng[:model] = options[:model]
-      end
-
-      def pci(options = {})
-        if options[:bus].nil? || options[:slot].nil? || options[:function].nil?
-          raise 'Bus AND slot AND function must be specified. Check `lspci` for that numbers.'
-        end
-
-        @pcis = [] if @pcis == UNSET_VALUE
-
-        @pcis.push(bus:       options[:bus],
-                   slot:      options[:slot],
-                   function:  options[:function])
-      end
-
-      def watchdog(options = {})
-        if options[:model].nil?
-          raise 'Model must be specified.'
-        end
-
-        if @watchdog_dev == UNSET_VALUE
-            @watchdog_dev = {}
-        end
-
-        @watchdog_dev[:model] = options[:model]
-        @watchdog_dev[:action] = options[:action] || 'reset'
-      end
-
-
-      def usb(options = {})
-        if (options[:bus].nil? || options[:device].nil?) && options[:vendor].nil? && options[:product].nil?
-          raise 'Bus and device and/or vendor and/or product must be specified. Check `lsusb` for these.'
-        end
-
-        @usbs = [] if @usbs == UNSET_VALUE
-
-        @usbs.push(bus:           options[:bus],
-                   device:        options[:device],
-                   vendor:        options[:vendor],
-                   product:       options[:product],
-                   startupPolicy: options[:startupPolicy])
-      end
-
-      def redirdev(options = {})
-        raise 'Type must be specified.' if options[:type].nil?
-
-        @redirdevs = [] if @redirdevs == UNSET_VALUE
-
-        @redirdevs.push(type: options[:type])
-      end
-
-      def redirfilter(options = {})
-        raise 'Option allow must be specified.' if options[:allow].nil?
-
-        @redirfilters = [] if @redirfilters == UNSET_VALUE
-
-        @redirfilters.push(class: options[:class] || -1,
-                           vendor: options[:class] || -1,
-                           product: options[:class] || -1,
-                           version: options[:class] || -1,
-                           allow: options[:allow])
-      end
-
-      def smartcard(options = {})
-        if options[:mode].nil?
-          raise 'Option mode must be specified.'
-        elsif options[:mode] != 'passthrough'
-          raise 'Currently only passthrough mode is supported!'
-        elsif options[:type] == 'tcp' && (options[:source_mode].nil? || options[:source_host].nil? || options[:source_service].nil?)
-          raise 'If using type "tcp", option "source_mode", "source_host" and "source_service" must be specified.'
-        end
-
-        if @smartcard_dev == UNSET_VALUE
-          @smartcard_dev = {}
-        end
-
-        @smartcard_dev[:mode] = options[:mode]
-        @smartcard_dev[:type] = options[:type] || 'spicevmc'
-        @smartcard_dev[:source_mode] = options[:source_mode] if @smartcard_dev[:type] == 'tcp'
-        @smartcard_dev[:source_host] = options[:source_host] if @smartcard_dev[:type] == 'tcp'
-        @smartcard_dev[:source_service] = options[:source_service] if @smartcard_dev[:type] == 'tcp'
-      end
-
-      # NOTE: this will run twice for each time it's needed- keep it idempotent
-      def storage(storage_type, options = {})
-        if storage_type == :file
-          if options[:device] == :cdrom
-            _handle_cdrom_storage(options)
-          else
-            _handle_disk_storage(options)
-          end
-        end
-      end
-
-      def _handle_cdrom_storage(options = {})
-        # <disk type="file" device="cdrom">
-        #   <source file="/home/user/virtio-win-0.1-100.iso"/>
-        #   <target dev="hdc"/>
-        #   <readonly/>
-        #   <address type='drive' controller='0' bus='1' target='0' unit='0'/>
-        # </disk>
-        #
-        # note the target dev will need to be changed with each cdrom drive (hdc, hdd, etc),
-        # as will the address unit number (unit=0, unit=1, etc)
-
-        options = {
-          bus: 'ide',
-          path: nil
-        }.merge(options)
-
-        cdrom = {
-          dev: options[:dev],
-          bus: options[:bus],
-          path: options[:path]
-        }
-
-        @cdroms << cdrom
-      end
-
-      def _handle_disk_storage(options = {})
-        options = {
-          type: 'qcow2',
-          size: '10G', # matches the fog default
-          path: nil,
-          bus: 'virtio'
-        }.merge(options)
-
-        disk = {
-          device: options[:device],
-          type: options[:type],
-          size: options[:size],
-          path: options[:path],
-          bus: options[:bus],
-          cache: options[:cache] || 'default',
-          allow_existing: options[:allow_existing],
-          shareable: options[:shareable],
-          serial: options[:serial]
-        }
-
-        @disks << disk # append
-      end
-
-      def qemuargs(options = {})
-        @qemu_args << options if options[:value]
-      end
-
-      # code to generate URI from a config moved out of the connect action
-      def _generate_uri
-        # builds the libvirt connection URI from the given driver config
-        # Setup connection uri.
-        uri = @driver.dup
-        virt_path = case uri
-                    when 'qemu', 'openvz', 'uml', 'phyp', 'parallels', 'kvm'
-                      '/system'
-                    when '@en', 'esx'
-                      '/'
-                    when 'vbox', 'vmwarews', 'hyperv'
-                      '/session'
-                    else
-                      raise "Require specify driver #{uri}"
-        end
-        if uri == 'kvm'
-          uri = 'qemu' # use qemu uri for kvm domain type
-        end
-
-        if @connect_via_ssh
-          uri << '+ssh://'
-          uri << @username + '@' if @username
-
-          uri << if @host
-                   @host
-                 else
-                   'localhost'
-                 end
-        else
-          uri << '://'
-          uri << @host if @host
-        end
-
-        uri << virt_path
-        uri << '?no_verify=1'
-
-        if @id_ssh_key_file
-          # set ssh key for access to libvirt host
-          uri << "\&keyfile="
-          # if no slash, prepend $HOME/.ssh/
-          @id_ssh_key_file.prepend("#{`echo ${HOME}`.chomp}/.ssh/") if @id_ssh_key_file !~ /\A\//
-          uri << @id_ssh_key_file
-        end
-        # set path to libvirt socket
-        uri << "\&socket=" + @socket if @socket
-        uri
-      end
-
-      def finalize!
-        @driver = 'kvm' if @driver == UNSET_VALUE
-        @host = nil if @host == UNSET_VALUE
-        @connect_via_ssh = false if @connect_via_ssh == UNSET_VALUE
-        @username = nil if @username == UNSET_VALUE
-        @password = nil if @password == UNSET_VALUE
-        @id_ssh_key_file = 'id_rsa' if @id_ssh_key_file == UNSET_VALUE
-        @storage_pool_name = 'default' if @storage_pool_name == UNSET_VALUE
-        @random_hostname = false if @random_hostname == UNSET_VALUE
-        @management_network_name = 'vagrant-libvirt' if @management_network_name == UNSET_VALUE
-        @management_network_address = '192.168.121.0/24' if @management_network_address == UNSET_VALUE
-        @management_network_mode = 'nat' if @management_network_mode == UNSET_VALUE
-        @management_network_mac = nil if @management_network_mac == UNSET_VALUE
-        @management_network_guest_ipv6 = 'yes' if @management_network_guest_ipv6 == UNSET_VALUE
-        @management_network_autostart = false if @management_network_autostart == UNSET_VALUE
-
-        # generate a URI if none is supplied
-        @uri = _generate_uri if @uri == UNSET_VALUE
-
-        # Domain specific settings.
-        @uuid = '' if @uuid == UNSET_VALUE
-        @memory = 512 if @memory == UNSET_VALUE
-        @cpus = 1 if @cpus == UNSET_VALUE
-        @cpu_mode = 'host-model' if @cpu_mode == UNSET_VALUE
-        @cpu_model = if (@cpu_model == UNSET_VALUE) && (@cpu_mode == 'custom')
-                       'qemu64'
-                     elsif @cpu_mode != 'custom'
-                       ''
-          end
-        @cpu_fallback = 'allow' if @cpu_fallback == UNSET_VALUE
-        @cpu_features = [] if @cpu_features == UNSET_VALUE
-        @features = ['acpi','apic','pae'] if @features == UNSET_VALUE
-        @numa_nodes = @numa_nodes == UNSET_VALUE ? nil : _generate_numa
-        @loader = nil if @loader == UNSET_VALUE
-        @machine_type = nil if @machine_type == UNSET_VALUE
-        @machine_arch = nil if @machine_arch == UNSET_VALUE
-        @machine_virtual_size = nil if @machine_virtual_size == UNSET_VALUE
-        @disk_bus = 'virtio' if @disk_bus == UNSET_VALUE
-        @disk_device = 'vda' if @disk_device == UNSET_VALUE
-        @nic_model_type = nil if @nic_model_type == UNSET_VALUE
-        @nested = false if @nested == UNSET_VALUE
-        @volume_cache = 'default' if @volume_cache == UNSET_VALUE
-        @kernel = nil if @kernel == UNSET_VALUE
-        @cmd_line = '' if @cmd_line == UNSET_VALUE
-        @initrd = '' if @initrd == UNSET_VALUE
-        @dtb = nil if @dtb == UNSET_VALUE
-        @graphics_type = 'vnc' if @graphics_type == UNSET_VALUE
-        @graphics_autoport = 'yes' if @graphics_port == UNSET_VALUE
-        @graphics_autoport = 'no' if @graphics_port != UNSET_VALUE
-        if (@graphics_type != 'vnc' && @graphics_type != 'spice') ||
-           @graphics_passwd == UNSET_VALUE
-          @graphics_passwd = nil
-        end
-        @graphics_port = 5900 if @graphics_port == UNSET_VALUE
-        @graphics_ip = '127.0.0.1' if @graphics_ip == UNSET_VALUE
-        @video_type = 'cirrus' if @video_type == UNSET_VALUE
-        @video_vram = 9216 if @video_vram == UNSET_VALUE
-        @sound_type = nil if @sound_type == UNSET_VALUE
-        @keymap = 'en-us' if @keymap == UNSET_VALUE
-        @kvm_hidden = false if @kvm_hidden == UNSET_VALUE
-        @tpm_model = 'tpm-tis' if @tpm_model == UNSET_VALUE
-        @tpm_type = 'passthrough' if @tpm_type == UNSET_VALUE
-        @tpm_path = nil if @tpm_path == UNSET_VALUE
-        @nic_adapter_count = 8 if @nic_adapter_count == UNSET_VALUE
-        @emulator_path = nil if @emulator_path == UNSET_VALUE
-
-        # Boot order
-        @boot_order = [] if @boot_order == UNSET_VALUE
-
-        # Storage
-        @disks = [] if @disks == UNSET_VALUE
-        @disks.map! do |disk|
-          disk[:device] = _get_device(@disks) if disk[:device].nil?
-          disk
-        end
-        @cdroms = [] if @cdroms == UNSET_VALUE
-        @cdroms.map! do |cdrom|
-          cdrom[:dev] = _get_cdrom_dev(@cdroms) if cdrom[:dev].nil?
-          cdrom
-        end
-
-        # Inputs
-        @inputs = [{ type: 'mouse', bus: 'ps2' }] if @inputs == UNSET_VALUE
-
-        # Channels
-        @channels = [] if @channels == UNSET_VALUE
-
-        # PCI device passthrough
-        @pcis = [] if @pcis == UNSET_VALUE
-
-        # Random number generator passthrough
-        @rng = {} if @rng == UNSET_VALUE
-
-        # Watchdog device
-        @watchdog_dev = {} if @watchdog_dev == UNSET_VALUE
-
-        # USB device passthrough
-        @usbs = [] if @usbs == UNSET_VALUE
-
-        # Redirected devices
-        @redirdevs = [] if @redirdevs == UNSET_VALUE
-        @redirfilters = [] if @redirfilters == UNSET_VALUE
-
-        # smartcard device
-        @smartcard_dev = {} if @smartcard_dev == UNSET_VALUE
-
-        # Suspend mode
-        @suspend_mode = 'pause' if @suspend_mode == UNSET_VALUE
-
-        # Autostart
-        @autostart = false if @autostart == UNSET_VALUE
-
-        # Attach mgmt network
-        @mgmt_attach = true if @mgmt_attach == UNSET_VALUE
-
-        @qemu_args = [] if @qemu_args == UNSET_VALUE
-      end
-
-      def validate(machine)
-        errors = _detected_errors
-
-        machine.provider_config.disks.each do |disk|
-          if disk[:path] && (disk[:path][0] == '/')
-            errors << "absolute volume paths like '#{disk[:path]}' not yet supported"
-          end
-        end
-
-        machine.config.vm.networks.each do |_type, opts|
-          if opts[:mac] && opts[:mac].downcase! && !(opts[:mac] =~ /\A([0-9a-f]{2}:){5}([0-9a-f]{2})\z/)
-            errors << "Configured NIC MAC '#{opts[:mac]}' is not in 'xx:xx:xx:xx:xx:xx' format"
-          end
-        end
-
-        { 'Libvirt Provider' => errors }
-      end
-
-      def merge(other)
-        super.tap do |result|
-          c = disks.dup
-          c += other.disks
-          result.disks = c
-
-          c = cdroms.dup
-          c += other.cdroms
-          result.cdroms = c
-        end
-      end
-    end
-  end
-end