vagrant-libvirt 0.0.41 → 0.0.42

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

@@ -0,0 +1,322 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      class CreateDomain
+        include VagrantPlugins::ProviderLibvirt::Util::ErbTemplate
+
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::create_domain')
+          @app = app
+        end
+
+        def _disk_name(name, disk)
+          "#{name}-#{disk[:device]}.#{disk[:type]}" # disk name
+        end
+
+        def _disks_print(disks)
+          disks.collect do |x|
+            "#{x[:device]}(#{x[:type]},#{x[:size]})"
+          end.join(', ')
+        end
+
+        def _cdroms_print(cdroms)
+          cdroms.collect { |x| x[:dev] }.join(', ')
+        end
+
+        def call(env)
+          # Get config.
+          config = env[:machine].provider_config
+
+          # Gather some info about domain
+          @name = env[:domain_name]
+          @uuid = config.uuid
+          @cpus = config.cpus.to_i
+          @cpu_features = config.cpu_features
+          @cpu_topology = config.cpu_topology
+          @features = config.features
+          @cpu_mode = config.cpu_mode
+          @cpu_model = config.cpu_model
+          @cpu_fallback = config.cpu_fallback
+          @numa_nodes = config.numa_nodes
+          @loader = config.loader
+          @machine_type = config.machine_type
+          @machine_arch = config.machine_arch
+          @disk_bus = config.disk_bus
+          @disk_device = config.disk_device
+          @nested = config.nested
+          @memory_size = config.memory.to_i * 1024
+          @memory_backing = config.memory_backing
+          @management_network_mac = config.management_network_mac
+          @domain_volume_cache = config.volume_cache
+          @kernel = config.kernel
+          @cmd_line = config.cmd_line
+          @emulator_path = config.emulator_path
+          @initrd = config.initrd
+          @dtb = config.dtb
+          @graphics_type = config.graphics_type
+          @graphics_autoport = config.graphics_autoport
+          @graphics_port = config.graphics_port
+          @graphics_ip = config.graphics_ip
+          @graphics_passwd = if config.graphics_passwd.to_s.empty?
+                               ''
+                             else
+                               "passwd='#{config.graphics_passwd}'"
+                              end
+          @video_type = config.video_type
+          @sound_type = config.sound_type
+          @video_vram = config.video_vram
+          @keymap = config.keymap
+          @kvm_hidden = config.kvm_hidden
+
+          @tpm_model = config.tpm_model
+          @tpm_type = config.tpm_type
+          @tpm_path = config.tpm_path
+
+          # Boot order
+          @boot_order = config.boot_order
+
+          # Storage
+          @storage_pool_name = config.storage_pool_name
+          @disks = config.disks
+          @cdroms = config.cdroms
+
+          # Input
+          @inputs = config.inputs
+
+          # Channels
+          @channels = config.channels
+
+          # PCI device passthrough
+          @pcis = config.pcis
+
+          # Watchdog device
+          @watchdog_dev = config.watchdog_dev
+
+          # USB device passthrough
+          @usbs = config.usbs
+
+          # Redirected devices
+          @redirdevs = config.redirdevs
+          @redirfilters = config.redirfilters
+
+          # smartcard device
+          @smartcard_dev = config.smartcard_dev
+
+          # RNG device passthrough
+          @rng = config.rng
+
+          config = env[:machine].provider_config
+          @domain_type = config.driver
+
+          @os_type = 'hvm'
+
+          # Get path to domain image from the storage pool selected if we have a box.
+          if env[:machine].config.vm.box
+            actual_volumes =
+              env[:machine].provider.driver.connection.volumes.all.select do |x|
+                x.pool_name == @storage_pool_name
+              end
+            domain_volume = ProviderLibvirt::Util::Collection.find_matching(
+              actual_volumes, "#{@name}.img"
+            )
+            raise Errors::DomainVolumeExists if domain_volume.nil?
+            @domain_volume_path = domain_volume.path
+          end
+
+          # If we have a box, take the path from the domain volume and set our storage_prefix.
+          # If not, we dump the storage pool xml to get its defined path.
+          # the default storage prefix is typically: /var/lib/libvirt/images/
+          if env[:machine].config.vm.box
+            storage_prefix = File.dirname(@domain_volume_path) + '/' # steal
+          else
+            storage_pool = env[:machine].provider.driver.connection.client.lookup_storage_pool_by_name(@storage_pool_name)
+            raise Errors::NoStoragePool if storage_pool.nil?
+            xml = Nokogiri::XML(storage_pool.xml_desc)
+            storage_prefix = xml.xpath('/pool/target/path').inner_text.to_s + '/'
+          end
+
+          @disks.each do |disk|
+            disk[:path] ||= _disk_name(@name, disk)
+
+            # On volume creation, the <path> element inside <target>
+            # is oddly ignored; instead the path is taken from the
+            # <name> element:
+            # http://www.redhat.com/archives/libvir-list/2008-August/msg00329.html
+            disk[:name] = disk[:path]
+
+            disk[:absolute_path] = storage_prefix + disk[:path]
+
+            if env[:machine].provider.driver.connection.volumes.select do |x|
+              x.name == disk[:name] && x.pool_name == @storage_pool_name
+            end.empty?
+              # make the disk. equivalent to:
+              # qemu-img create -f qcow2 <path> 5g
+              begin
+                env[:machine].provider.driver.connection.volumes.create(
+                  name: disk[:name],
+                  format_type: disk[:type],
+                  path: disk[:absolute_path],
+                  capacity: disk[:size],
+                  #:allocation => ?,
+                  pool_name: @storage_pool_name
+                )
+              rescue Fog::Errors::Error => e
+                raise Errors::FogDomainVolumeCreateError,
+                      error_message: e.message
+              end
+            else
+              disk[:preexisting] = true
+            end
+          end
+
+          # 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(" -- Forced UUID:       #{@uuid}") if @uuid != ''
+          env[:ui].info(" -- Domain type:       #{@domain_type}")
+          env[:ui].info(" -- Cpus:              #{@cpus}")
+          if not @cpu_topology.empty?
+            env[:ui].info(" -- CPU topology:   sockets=#{@cpu_topology[:sockets]}, cores=#{@cpu_topology[:cores]}, threads=#{@cpu_topology[:threads]}")
+          end
+          env[:ui].info("")
+          @cpu_features.each do |cpu_feature|
+            env[:ui].info(" -- CPU Feature:       name=#{cpu_feature[:name]}, policy=#{cpu_feature[:policy]}")
+          end
+          @features.each do |feature|
+            env[:ui].info(" -- Feature:           #{feature}")
+          end
+          env[:ui].info(" -- Memory:            #{@memory_size / 1024}M")
+          @memory_backing.each do |backing|
+            env[:ui].info(" -- Memory Backing:    #{backing[:name]}: #{backing[:config].map { |k,v| "#{k}='#{v}'"}.join(' ')}")
+          end
+          env[:ui].info(" -- Management MAC:    #{@management_network_mac}")
+          env[:ui].info(" -- Loader:            #{@loader}")
+          if env[:machine].config.vm.box
+            env[:ui].info(" -- Base box:          #{env[:machine].box.name}")
+          end
+          env[:ui].info(" -- Storage pool:      #{@storage_pool_name}")
+          env[:ui].info(" -- Image:             #{@domain_volume_path} (#{env[:box_virtual_size]}G)")
+          env[:ui].info(" -- Volume Cache:      #{@domain_volume_cache}")
+          env[:ui].info(" -- Kernel:            #{@kernel}")
+          env[:ui].info(" -- Initrd:            #{@initrd}")
+          env[:ui].info(" -- Graphics Type:     #{@graphics_type}")
+          env[:ui].info(" -- Graphics Port:     #{@graphics_port}")
+          env[:ui].info(" -- Graphics IP:       #{@graphics_ip}")
+          env[:ui].info(" -- Graphics Password: #{@graphics_passwd.empty? ? 'Not defined' : 'Defined'}")
+          env[:ui].info(" -- Video Type:        #{@video_type}")
+          env[:ui].info(" -- Video VRAM:        #{@video_vram}")
+          env[:ui].info(" -- Sound Type:	#{@sound_type}")
+          env[:ui].info(" -- Keymap:            #{@keymap}")
+          env[:ui].info(" -- TPM Path:          #{@tpm_path}")
+
+          @boot_order.each do |device|
+            env[:ui].info(" -- Boot device:        #{device}")
+          end
+
+          unless @disks.empty?
+            env[:ui].info(" -- Disks:         #{_disks_print(@disks)}")
+          end
+
+          @disks.each do |disk|
+            msg = " -- Disk(#{disk[:device]}):     #{disk[:absolute_path]}"
+            msg += ' Shared' if disk[:shareable]
+            msg += ' (Remove only manually)' if disk[:allow_existing]
+            msg += ' Not created - using existed.' if disk[:preexisting]
+            env[:ui].info(msg)
+          end
+
+          unless @cdroms.empty?
+            env[:ui].info(" -- CDROMS:            #{_cdroms_print(@cdroms)}")
+          end
+
+          @cdroms.each do |cdrom|
+            env[:ui].info(" -- CDROM(#{cdrom[:dev]}):        #{cdrom[:path]}")
+          end
+
+          @inputs.each do |input|
+            env[:ui].info(" -- INPUT:             type=#{input[:type]}, bus=#{input[:bus]}")
+          end
+
+          @channels.each do |channel|
+            env[:ui].info(" -- CHANNEL:             type=#{channel[:type]}, mode=#{channel[:source_mode]}")
+            env[:ui].info(" -- CHANNEL:             target_type=#{channel[:target_type]}, target_name=#{channel[:target_name]}")
+          end
+
+          @pcis.each do |pci|
+            env[:ui].info(" -- PCI passthrough:   #{pci[:bus]}:#{pci[:slot]}.#{pci[:function]}")
+          end
+
+          unless @rng[:model].nil?
+            env[:ui].info(" -- RNG device model:  #{@rng[:model]}")
+          end
+
+          if not @watchdog_dev.empty?
+            env[:ui].info(" -- Watchdog device:   model=#{@watchdog_dev[:model]}, action=#{@watchdog_dev[:action]}")
+          end
+
+          @usbs.each do |usb|
+            usb_dev = []
+            usb_dev.push("bus=#{usb[:bus]}") if usb[:bus]
+            usb_dev.push("device=#{usb[:device]}") if usb[:device]
+            usb_dev.push("vendor=#{usb[:vendor]}") if usb[:vendor]
+            usb_dev.push("product=#{usb[:product]}") if usb[:product]
+            env[:ui].info(" -- USB passthrough:   #{usb_dev.join(', ')}")
+          end
+
+          unless @redirdevs.empty?
+            env[:ui].info(' -- Redirected Devices: ')
+            @redirdevs.each do |redirdev|
+              msg = "    -> bus=usb, type=#{redirdev[:type]}"
+              env[:ui].info(msg)
+            end
+          end
+
+          unless @redirfilters.empty?
+            env[:ui].info(' -- USB Device filter for Redirected Devices: ')
+            @redirfilters.each do |redirfilter|
+              msg = "    -> class=#{redirfilter[:class]}, "
+              msg += "vendor=#{redirfilter[:vendor]}, "
+              msg += "product=#{redirfilter[:product]}, "
+              msg += "version=#{redirfilter[:version]}, "
+              msg += "allow=#{redirfilter[:allow]}"
+              env[:ui].info(msg)
+            end
+          end
+
+          if not @smartcard_dev.empty?
+            env[:ui].info(" -- smartcard device:  mode=#{@smartcard_dev[:mode]}, type=#{@smartcard_dev[:type]}")
+          end
+
+          @qargs = config.qemu_args
+          if not @qargs.empty?
+            env[:ui].info(' -- Command line args: ')
+            @qargs.each do |arg|
+              msg = "    -> value=#{arg[:value]}, "
+              env[:ui].info(msg)
+            end
+          end
+
+          env[:ui].info(" -- Command line : #{@cmd_line}") unless @cmd_line.empty?
+
+          # 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[:machine].provider.driver.connection.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,87 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    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::ProviderLibvirt::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 = ProviderLibvirt::Util::Collection.find_matching(
+            env[:machine].provider.driver.connection.volumes.all, @name
+          )
+          raise Errors::DomainVolumeExists if domain_volume
+
+          # Get path to backing image - box volume.
+          box_volume = ProviderLibvirt::Util::Collection.find_matching(
+            env[:machine].provider.driver.connection.volumes.all, env[:box_volume_name]
+          )
+          @backing_file = box_volume.path
+
+          # Virtual size of image. Take value worked out by HandleBoxImage
+          @capacity = env[:box_virtual_size] # G
+
+          # Create new volume from xml template. Fog currently doesn't support
+          # volume snapshots directly.
+          begin
+            xml = Nokogiri::XML::Builder.new do |xml|
+              xml.volume do
+                xml.name(@name)
+                xml.capacity(@capacity, unit: 'G')
+                xml.target do
+                  xml.format(type: 'qcow2')
+                  xml.permissions do
+                    xml.owner 0
+                    xml.group 0
+                    xml.mode '0600'
+                    xml.label 'virt_image_t'
+                  end
+                end
+                xml.backingStore do
+                  xml.path(@backing_file)
+                  xml.format(type: 'qcow2')
+                  xml.permissions do
+                    xml.owner 0
+                    xml.group 0
+                    xml.mode '0600'
+                    xml.label 'virt_image_t'
+                  end
+                end
+              end
+            end.to_xml(
+              save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION |
+                         Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
+                         Nokogiri::XML::Node::SaveOptions::FORMAT
+            )
+            domain_volume = env[:machine].provider.driver.connection.volumes.create(
+              xml: xml,
+              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,302 @@
+require 'log4r'
+require 'vagrant/util/network_ip'
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Create network interfaces for domain, before domain is running.
+      # Networks for connecting those interfaces should be already prepared.
+      class CreateNetworkInterfaces
+        include VagrantPlugins::ProviderLibvirt::Util::ErbTemplate
+        include VagrantPlugins::ProviderLibvirt::Util::NetworkUtil
+        include Vagrant::Util::NetworkIP
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::create_network_interfaces')
+          @management_network_name = env[:machine].provider_config.management_network_name
+          config = env[:machine].provider_config
+          @nic_model_type = config.nic_model_type || 'virtio'
+          @nic_adapter_count = config.nic_adapter_count
+          @app = app
+        end
+
+        def call(env)
+          # Get domain first.
+          begin
+            domain = env[:machine].provider.driver.connection.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 = []
+
+          # Vagrant gives you adapter 0 by default
+          # Assign interfaces to slots.
+          configured_networks(env, @logger).each do |options|
+            # dont need to create interface for this type
+            next if options[:iface_type] == :forwarded_port
+
+            # TODO: fill first ifaces with adapter option specified.
+            if options[:adapter]
+              if adapters[options[:adapter]]
+                raise Errors::InterfaceSlotNotAvailable
+              end
+
+              free_slot = options[:adapter].to_i
+              @logger.debug "Using specified adapter slot #{free_slot}"
+            else
+              free_slot = find_empty(adapters)
+              @logger.debug "Adapter not specified so found slot #{free_slot}"
+              raise Errors::InterfaceSlotExhausted if free_slot.nil?
+            end
+
+            # We have slot for interface, fill it with interface configuration.
+            adapters[free_slot] = options
+            adapters[free_slot][:network_name] = interface_network(
+              env[:machine].provider.driver.connection.client, adapters[free_slot]
+            )
+          end
+
+          # Create each interface as new domain device.
+          @macs_per_network = Hash.new(0)
+          adapters.each_with_index do |iface_configuration, slot_number|
+            @iface_number = slot_number
+            @network_name = iface_configuration[:network_name]
+            @source_options = {
+              network: @network_name
+            }
+            @mac = iface_configuration.fetch(:mac, false)
+            @model_type = iface_configuration.fetch(:model_type, @nic_model_type)
+            @driver_name = iface_configuration.fetch(:driver_name, false)
+            @driver_queues = iface_configuration.fetch(:driver_queues, false)
+            @device_name = iface_configuration.fetch(:iface_name, false)
+            @mtu = iface_configuration.fetch(:mtu, nil)
+            @pci_bus = iface_configuration.fetch(:bus, nil)
+            @pci_slot = iface_configuration.fetch(:slot, nil)
+            template_name = 'interface'
+            # Configuration for public interfaces which use the macvtap driver
+            if iface_configuration[:iface_type] == :public_network
+              @device = iface_configuration.fetch(:dev, 'eth0')
+              @mode = iface_configuration.fetch(:mode, 'bridge')
+              @type = iface_configuration.fetch(:type, 'direct')
+              @model_type = iface_configuration.fetch(:model_type, @nic_model_type)
+              @driver_name = iface_configuration.fetch(:driver_name, false)
+              @driver_queues = iface_configuration.fetch(:driver_queues, false)
+              @portgroup = iface_configuration.fetch(:portgroup, nil)
+              @network_name = iface_configuration.fetch(:network_name, @network_name)
+              template_name = 'public_interface'
+              @logger.info("Setting up public interface using device #{@device} in mode #{@mode}")
+              @ovs = iface_configuration.fetch(:ovs, false)
+              @trust_guest_rx_filters = iface_configuration.fetch(:trust_guest_rx_filters, false)
+            # configuration for udp or tcp tunnel interfaces (p2p conn btwn guest OSes)
+            elsif iface_configuration.fetch(:tunnel_type, nil)
+              @type = iface_configuration.fetch(:tunnel_type)
+              @tunnel_port = iface_configuration.fetch(:tunnel_port, nil)
+              raise Errors::TunnelPortNotDefined if @tunnel_port.nil?
+              if @type == 'udp'
+                # default udp tunnel source to 127.0.0.1
+                @udp_tunnel={
+                  address: iface_configuration.fetch(:tunnel_local_ip,'127.0.0.1'),
+                  port: iface_configuration.fetch(:tunnel_local_port)
+                }
+              end
+              # default mcast tunnel to 239.255.1.1. Web search says this
+              # 239.255.x.x is a safe range to use for general use mcast
+              default_ip = if @type == 'mcast'
+                             '239.255.1.1'
+                           else
+                             '127.0.0.1'
+                           end
+              @source_options = {
+                address: iface_configuration.fetch(:tunnel_ip, default_ip),
+                port: @tunnel_port
+              }
+              @tunnel_type = iface_configuration.fetch(:model_type, @nic_model_type)
+              @driver_name = iface_configuration.fetch(:driver_name, false)
+              @driver_queues = iface_configuration.fetch(:driver_queues, false)
+              template_name = 'tunnel_interface'
+              @logger.info("Setting up #{@type} tunnel interface using  #{@tunnel_ip} port #{@tunnel_port}")
+            end
+
+            message = "Creating network interface eth#{@iface_number}"
+            message << " connected to network #{@network_name}."
+            if @mac
+              @mac = @mac.scan(/(\h{2})/).join(':')
+              message << " Using MAC address: #{@mac}"
+            end
+            @logger.info(message)
+
+            begin
+              # FIXME: all options for network driver should be hash from Vagrantfile
+              driver_options = {}
+              driver_options[:name] = @driver_name if @driver_name
+              driver_options[:queues] = @driver_queues if @driver_queues
+              @udp_tunnel ||= {}
+              xml = if template_name == 'interface' or
+                       template_name == 'tunnel_interface'
+                      interface_xml(@type,
+                                    @source_options,
+                                    @mac,
+                                    @device_name,
+                                    @iface_number,
+                                    @model_type,
+                                    @mtu,
+                                    driver_options,
+                                    @udp_tunnel,
+                                    @pci_bus,
+                                    @pci_slot)
+                    else
+                      to_xml(template_name)
+                    end
+              domain.attach_device(xml)
+            rescue => e
+              raise Errors::AttachDeviceError,
+                    error_message: e.message
+            end
+
+            # Re-read the network configuration and grab the MAC address
+            if iface_configuration[:iface_type] == :public_network
+              xml = Nokogiri::XML(domain.xml_desc)
+              source = "@network='#{@network_name}'"
+              if @type == 'direct'
+                  source = "@dev='#{@device}'"
+              elsif @portgroup.nil?
+                source = "@bridge='#{@device}'"
+              end
+              if not @mac
+                macs = xml.xpath("/domain/devices/interface[source[#{source}]]/mac/@address")
+                @mac = macs[@macs_per_network[source]]
+                iface_configuration[:mac] = @mac.to_s
+              end
+              @macs_per_network[source] += 1
+            end
+          end
+
+          # Continue the middleware chain.
+          @app.call(env)
+
+          if env[:machine].config.vm.box
+            # Configure interfaces that user requested. Machine should be up and
+            # running now.
+            networks_to_configure = []
+
+            adapters.each_with_index do |options, slot_number|
+              # Skip configuring the management network, which is on the first interface.
+              # It's used for provisioning and it has to be available during provisioning,
+              # ifdown command is not acceptable here.
+              next if slot_number.zero?
+              next if options[:auto_config] === false
+              @logger.debug "Configuring interface slot_number #{slot_number} options #{options}"
+
+              network = {
+                interface: slot_number,
+                use_dhcp_assigned_default_route: options[:use_dhcp_assigned_default_route],
+                mac_address: options[:mac]
+              }
+
+              if options[:ip]
+                network = {
+                  type: :static,
+                  ip: options[:ip],
+                  netmask: options[:netmask],
+                  gateway: options[:gateway]
+                }.merge(network)
+              else
+                network[:type] = :dhcp
+              end
+
+              # do not run configure_networks for tcp tunnel interfaces
+              next if options.fetch(:tunnel_type, nil)
+
+              networks_to_configure << network
+            end
+
+            env[:ui].info I18n.t('vagrant.actions.vm.network.configuring')
+            env[:machine].guest.capability(
+              :configure_networks, networks_to_configure
+            )
+
+          end
+        end
+
+        private
+
+        def target_dev_name(device_name, type, iface_number)
+          if device_name
+            device_name
+          elsif type == 'network'
+            "vnet#{iface_number}"
+          else
+            # TODO can we use same name vnet#ifnum?
+            #"tnet#{iface_number}" FIXME plugin vagrant-libvirt trying to create second tnet0 interface
+            "vnet#{iface_number}"
+          end
+        end
+
+        def interface_xml(type, source_options, mac, device_name,
+                          iface_number, model_type, mtu, driver_options,
+                          udp_tunnel={}, pci_bus, pci_slot)
+          Nokogiri::XML::Builder.new do |xml|
+            xml.interface(type: type || 'network') do
+              xml.source(source_options) do
+                xml.local(udp_tunnel) if type == 'udp'
+              end
+              xml.mac(address: mac) if mac
+              xml.target(dev: target_dev_name(device_name, type, iface_number))
+              xml.alias(name: "net#{iface_number}")
+              xml.model(type: model_type.to_s)
+              xml.mtu(size: Integer(mtu)) if mtu
+              xml.driver(driver_options)
+              xml.address(type: 'pci', bus: pci_bus, slot: pci_slot) if pci_bus and pci_slot
+            end
+          end.to_xml(
+            save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION |
+                       Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
+                       Nokogiri::XML::Node::SaveOptions::FORMAT
+          )
+        end
+
+        def find_empty(array, start = 0, stop = @nic_adapter_count)
+          (start..stop).each do |i|
+            return i unless array[i]
+          end
+          nil
+        end
+
+        # Return network name according to interface options.
+        def interface_network(libvirt_client, options)
+          # no need to get interface network for tcp tunnel config
+          return 'tunnel_interface' if options.fetch(:tunnel_type, nil)
+
+          if options[:network_name]
+            @logger.debug 'Found network by name'
+            return options[:network_name]
+          end
+
+          # Get list of all (active and inactive) libvirt networks.
+          available_networks = libvirt_networks(libvirt_client)
+
+          return 'public' if options[:iface_type] == :public_network
+
+          if options[:ip]
+            address = network_address(options[:ip], options[:netmask])
+            available_networks.each do |network|
+              if address == network[:network_address]
+                @logger.debug 'Found network by ip'
+                return network[:name]
+              end
+            end
+          end
+
+          raise Errors::NetworkNotAvailableError, network_name: options[:ip]
+        end
+      end
+    end
+  end
+end