# File lib/vagrant-libvirt/action/create_network_interfaces.rb, line 25
        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'
            @type = nil
            @udp_tunnel = nil
            # 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