vagrant-libvirt 0.0.40 → 0.0.41

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

@@ -1,313 +0,0 @@
-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
-          @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
-          @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}")
-          @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")
-          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

@@ -1,87 +0,0 @@
-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

@@ -1,294 +0,0 @@
-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::InterfaceSlotNotAvailable 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)
-            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,
-                                    driver_options,
-                                    @udp_tunnel)
-                    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 == 'netwrok'
-            "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, driver_options,
-                          udp_tunnel={})
-          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.driver(driver_options)
-            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