vagrant-libvirt 0.0.30 → 0.0.31

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

@@ -6,7 +6,7 @@ module VagrantPlugins
       class CreateDomain
         include VagrantPlugins::ProviderLibvirt::Util::ErbTemplate
 
-        def initialize(app, env)
+        def initialize(app, _env)
           @logger = Log4r::Logger.new('vagrant_libvirt::action::create_domain')
           @app = app
         end
@@ -17,7 +17,7 @@ module VagrantPlugins
 
         def _disks_print(disks)
           disks.collect do |x|
-            x[:device] + '(' + x[:type] + ',' + x[:size] + ')'
+            "#{x[:device]}(#{x[:type]},#{x[:size]})"
           end.join(', ')
         end
 
@@ -33,11 +33,13 @@ module VagrantPlugins
           @name = env[:domain_name]
           @cpus = config.cpus.to_i
           @cpu_mode = config.cpu_mode
+          @loader = config.loader
           @machine_type = config.machine_type
           @machine_arch = config.machine_arch
           @disk_bus = config.disk_bus
           @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
@@ -49,12 +51,12 @@ module VagrantPlugins
           @graphics_passwd =  if config.graphics_passwd.to_s.empty?
                                 ''
                               else
-                                "passwd='#{config.graphics_passwd.to_s}'"
+                                "passwd='#{config.graphics_passwd}'"
                               end
           @video_type = config.video_type
           @video_vram = config.video_vram
           @keymap = config.keymap
-          
+
           # Boot order
           @boot_order = config.boot_order
 
@@ -63,19 +65,37 @@ module VagrantPlugins
           @disks = config.disks
           @cdroms = config.cdroms
 
+          # Input
+          @inputs = config.inputs
+
           config = env[:machine].provider_config
           @domain_type = config.driver
 
           @os_type = 'hvm'
 
-          # Get path to domain image.
-          domain_volume = ProviderLibvirt::Util::Collection.find_matching(
-            env[:libvirt_compute].volumes.all, "#{@name}.img")
-          raise Errors::DomainVolumeExists if domain_volume.nil?
-          @domain_volume_path = domain_volume.path
+          # Get path to domain image from the storage pool selected if we have a box.
+          if env[:machine].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/
-          storage_prefix = File.dirname(@domain_volume_path) + '/'	# steal
+          if env[:machine].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)
@@ -88,11 +108,13 @@ module VagrantPlugins
 
             disk[:absolute_path] = storage_prefix + disk[:path]
 
-            if env[:libvirt_compute].volumes.all.select {|x| x.name == disk[:name] }.empty?
+            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[:libvirt_compute].volumes.create(
+                env[:machine].provider.driver.connection.volumes.create(
                   name: disk[:name],
                   format_type: disk[:type],
                   path: disk[:absolute_path],
@@ -114,9 +136,13 @@ module VagrantPlugins
           env[:ui].info(" -- Domain type:       #{@domain_type}")
           env[:ui].info(" -- Cpus:              #{@cpus}")
           env[:ui].info(" -- Memory:            #{@memory_size / 1024}M")
-          env[:ui].info(" -- Base box:          #{env[:machine].box.name}")
+          env[:ui].info(" -- Management MAC:    #{@management_network_mac}")
+          env[:ui].info(" -- Loader:            #{@loader}")
+          if env[:machine].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[: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}")
@@ -127,7 +153,7 @@ module VagrantPlugins
           env[:ui].info(" -- Video Type:        #{@video_type}")
           env[:ui].info(" -- Video VRAM:        #{@video_vram}")
           env[:ui].info(" -- Keymap:            #{@keymap}")
-          
+
           @boot_order.each do |device|
             env[:ui].info(" -- Boot device:        #{device}")
           end
@@ -138,8 +164,8 @@ module VagrantPlugins
 
           @disks.each do |disk|
             msg = " -- Disk(#{disk[:device]}):     #{disk[:absolute_path]}"
-            msg += " (shared. Remove only manualy)" if disk[:allow_existing]
-            msg += " Not created - using existed." if disk[:preexisting]
+            msg += ' (shared. Remove only manually)' if disk[:allow_existing]
+            msg += ' Not created - using existed.' if disk[:preexisting]
             env[:ui].info(msg)
           end
 
@@ -150,14 +176,16 @@ module VagrantPlugins
           @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
           env[:ui].info(" -- Command line : #{@cmd_line}")
 
           # 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[:libvirt_compute].servers.create(
+            server = env[:machine].provider.driver.connection.servers.create(
               xml: to_xml('domain'))
           rescue Fog::Errors::Error => e
             raise Errors::FogCreateServerError, error_message:  e.message

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

@@ -26,21 +26,21 @@ module VagrantPlugins
 
           # Verify the volume doesn't exist already.
           domain_volume = ProviderLibvirt::Util::Collection.find_matching(
-            env[:libvirt_compute].volumes.all, @name)
+            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[:libvirt_compute].volumes.all, env[:box_volume_name])
+            env[:machine].provider.driver.connection.volumes.all, env[:box_volume_name])
           @backing_file = box_volume.path
 
-          # Virtual size of image. Same as box image size.
-          @capacity = env[:machine].box.metadata['virtual_size'] #G
+          # 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
-            domain_volume = env[:libvirt_compute].volumes.create(
+            domain_volume = env[:machine].provider.driver.connection.volumes.create(
               :xml       => to_xml('volume_snapshot'),
               :pool_name => config.storage_pool_name)
           rescue Fog::Errors::Error => e

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

@@ -19,13 +19,14 @@ module VagrantPlugins
           @management_network_name = env[:machine].provider_config.management_network_name
 	        config = env[:machine].provider_config
 	        @nic_model_type = config.nic_model_type
+          @nic_adapter_count = config.nic_adapter_count
           @app = app
         end
 
         def call(env)
           # Get domain first.
           begin
-            domain = env[:libvirt_compute].client.lookup_domain_by_uuid(
+            domain = env[:machine].provider.driver.connection.client.lookup_domain_by_uuid(
               env[:machine].id.to_s)
           rescue => e
             raise Errors::NoDomainError,
@@ -36,7 +37,6 @@ module VagrantPlugins
           adapters = []
 
           # Vagrant gives you adapter 0 by default
-
           # Assign interfaces to slots.
           configured_networks(env, @logger).each do |options|
 
@@ -60,7 +60,7 @@ module VagrantPlugins
             # We have slot for interface, fill it with interface configuration.
             adapters[free_slot] = options
             adapters[free_slot][:network_name] = interface_network(
-              env[:libvirt_compute].client, adapters[free_slot])
+              env[:machine].provider.driver.connection.client, adapters[free_slot])
           end
 
           # Create each interface as new domain device.
@@ -70,7 +70,6 @@ module VagrantPlugins
             @mac = iface_configuration.fetch(:mac, false)
             @model_type = iface_configuration.fetch(:model_type, @nic_model_type)
             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')
@@ -80,8 +79,30 @@ module VagrantPlugins
               template_name = 'public_interface'
               @logger.info("Setting up public interface using device #{@device} in mode #{@mode}")
               @ovs = iface_configuration.fetch(:ovs, 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_local_ip = iface_configuration.fetch(:tunnel_local_ip, '127.0.0.1')
+                @udp_tunnel_local_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
+              if @type == 'mcast'
+                default_ip = '239.255.1.1'
+              else
+                default_ip = '127.0.0.1'
+              end
+              @tunnel_ip = iface_configuration.fetch(:tunnel_address, default_ip)
+              @model_type = iface_configuration.fetch(:model_type, @nic_model_type)
+              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
@@ -96,58 +117,83 @@ module VagrantPlugins
               raise Errors::AttachDeviceError,
                 :error_message => e.message
             end
+
+            # Re-read the network configuration and grab the MAC address
+            unless @mac
+              xml = Nokogiri::XML(domain.xml_desc)
+              if iface_configuration[:iface_type] == :public_network
+                if @type == 'direct'
+                  @mac = xml.xpath("/domain/devices/interface[source[@dev='#{@device}']]/mac/@address")
+                else
+                  @mac = xml.xpath("/domain/devices/interface[source[@bridge='#{@device}']]/mac/@address")
+                end
+              else
+                @mac = xml.xpath("/domain/devices/interface[source[@network='#{@network_name}']]/mac/@address")
+              end
+              iface_configuration[:mac] = @mac.to_s
+            end
           end
 
           # Continue the middleware chain.
           @app.call(env)
 
-          # 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 == 0
-            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 => ...,
-            }
-
-            if options[:ip]
+
+          if env[:machine].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 == 0
+              next if options[:auto_config] === false
+              @logger.debug "Configuring interface slot_number #{slot_number} options #{options}"
+
               network = {
-                :type    => :static,
-                :ip      => options[:ip],
-                :netmask => options[:netmask],
-              }.merge(network)
-            else
-              network[:type] = :dhcp
+                :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],
+                }.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
 
-            networks_to_configure << network
-          end
+            env[:ui].info I18n.t('vagrant.actions.vm.network.configuring')
+            env[:machine].guest.capability(
+              :configure_networks, networks_to_configure)
 
-          env[:ui].info I18n.t('vagrant.actions.vm.network.configuring')
-          env[:machine].guest.capability(
-            :configure_networks, networks_to_configure)
+          end
         end
 
         private
 
-        def find_empty(array, start=0, stop=8)
+        def find_empty(array, start=0, stop=@nic_adapter_count)
           (start..stop).each do |i|
-            return i if !array[i]
+            return i unless array[i]
           end
           return 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]

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

@@ -23,7 +23,7 @@ module VagrantPlugins
 
           @available_networks = []
           @options = {}
-          @libvirt_client = env[:libvirt_compute].client
+          @libvirt_client = env[:machine].provider.driver.connection.client
         end
 
         def call(env)
@@ -35,7 +35,8 @@ module VagrantPlugins
             # available, create it if possible. Otherwise raise an error.
             configured_networks(env, @logger).each do |options|
               # Only need to create private networks
-              next if options[:iface_type] != :private_network
+              next if options[:iface_type] != :private_network ||
+                options.fetch(:tunnel_type, nil)
               @logger.debug "Searching for network with options #{options}"
 
               # should fix other methods so this doesn't have to be instance var
@@ -45,7 +46,7 @@ module VagrantPlugins
               # list is used throughout this class and should be easier to
               # process than libvirt API calls.
               @available_networks = libvirt_networks(
-                                      env[:libvirt_compute].client)
+                                      env[:machine].provider.driver.connection.client)
 
               # Prepare a hash describing network for this specific interface.
               @interface_network = {
@@ -62,15 +63,16 @@ module VagrantPlugins
 
               if @options[:ip]
                 handle_ip_option(env)
-              # in vagrant 1.2.3 and later it is not possible to take this branch
-              # because cannot have name without ip
-              # https://github.com/mitchellh/vagrant/commit/cf2f6da4dbcb4f57c9cdb3b94dcd0bba62c5f5fd
+              elsif @options[:type].to_s == 'dhcp'
+                handle_dhcp_private_network(env)
               elsif @options[:network_name]
-                handle_network_name_option
+                handle_network_name_option(env)
+              else
+                raise Errors::CreateNetworkError, error_message: @options
               end
 
-              autostart_network if !@interface_network[:autostart]
-              activate_network if !@interface_network[:active]
+              autostart_network if @interface_network[:autostart]
+              activate_network unless @interface_network[:active]
             end
           end
 
@@ -79,22 +81,21 @@ module VagrantPlugins
 
         private
 
+        def lookup_network_by_ip(ip)
+          @logger.debug "looking up network with ip == #{ip}"
+          @available_networks.find { |network| network[:network_address] == ip }
+        end
+
         # Return hash of network for specified name, or nil if not found.
         def lookup_network_by_name(network_name)
           @logger.debug "looking up network named #{network_name}"
-          @available_networks.each do |network|
-            return network if network[:name] == network_name
-          end
-          nil
+          @available_networks.find { |network| network[:name] == network_name }
         end
 
         # Return hash of network for specified bridge, or nil if not found.
         def lookup_bridge_by_name(bridge_name)
           @logger.debug "looking up bridge named #{bridge_name}"
-          @available_networks.each do |network|
-            return network if network[:bridge_name] == bridge_name
-          end
-          nil
+          @available_networks.find { |network| network[:bridge_name] == bridge_name }
         end
 
         # Throw an error if dhcp setting for an existing network does not
@@ -114,28 +115,30 @@ module VagrantPlugins
         # Handle only situations, when ip is specified. Variables @options and
         # @available_networks should be filled before calling this function.
         def handle_ip_option(env)
-          return if !@options[:ip]
+          return unless @options[:ip]
+          net_address = nil
+          unless @options[:forward_mode] == 'veryisolated'
+            net_address = network_address(@options[:ip], @options[:netmask])
+
+            # Set IP address of network (actually bridge). It will be used as
+            # gateway address for machines connected to this network.
+            @interface_network[:ip_address] = get_host_ip_addr(net_address)
+          end
 
-          net_address = network_address(@options[:ip], @options[:netmask])
           @interface_network[:network_address] = net_address
 
-          # Set IP address of network (actually bridge). It will be used as
-          # gateway address for machines connected to this network.
-          net = IPAddr.new(net_address)
-          # Default to first address (after network name)
-          @interface_network[:ip_address] = @options[:host_ip].nil? ? net.to_range.begin.succ : IPAddr.new(@options[:host_ip])
-
-          # Is there an available network matching to configured ip
-          # address?
-          @available_networks.each do |available_network|
-            if available_network[:network_address] == \
-            @interface_network[:network_address]
-              @interface_network = available_network
-              @logger.debug "found existing network by ip, values are"
-              @logger.debug @interface_network
-              break
-            end
+          # if network is veryisolated, search by name
+          if @options[:libvirt__forward_mode] == "veryisolated"
+            network = lookup_network_by_name(@options[:network_name])
+          elsif net_address
+            # otherwise, search by ip (if set)
+            network = lookup_network_by_ip(net_address)
+          else
+            # leaving this here to mimic prior behavior. If we get
+            # here, something's probably broken.
+            network = lookup_network_by_name(@options[:network_name])
           end
+          @interface_network = network if network
 
           if @interface_network[:created]
             verify_dhcp
@@ -167,7 +170,7 @@ module VagrantPlugins
           end
 
           # Do we need to create new network?
-          if !@interface_network[:created]
+          unless @interface_network[:created]
 
             # TODO: stop after some loops. Don't create infinite loops.
 
@@ -188,17 +191,7 @@ module VagrantPlugins
             end
 
             # Generate a unique name for network bridge.
-            count = 0
-            while @interface_network[:bridge_name].nil?
-              @logger.debug "generating name for bridge"
-              bridge_name = 'virbr'
-              bridge_name << count.to_s
-              count += 1
-
-              next if lookup_bridge_by_name(bridge_name)
-
-              @interface_network[:bridge_name] = bridge_name
-            end
+            @interface_network[:bridge_name] = generate_bridge_name
 
             # Create a private network.
             create_private_network(env)
@@ -208,16 +201,68 @@ module VagrantPlugins
         # Handle network_name option, if ip was not specified. Variables
         # @options and @available_networks should be filled before calling this
         # function.
-        def handle_network_name_option
-          return if @options[:ip] || !@options[:network_name]
+        def handle_network_name_option(env)
+          return if @options[:ip] || \
+                    !@options[:network_name] || \
+                    !@options[:libvirt__forward_mode] == "veryisolated"
+
+          network = lookup_network_by_name(@options[:network_name])
+          @interface_network = network if network
 
-          @interface_network = lookup_network_by_name(@options[:network_name])
-          if !@interface_network
+          # if this interface has a network address, something's wrong.
+          if @interface_network[:network_address]
             raise Errors::NetworkNotAvailableError,
                   network_name: @options[:network_name]
-          else
-            verify_dhcp
           end
+
+          # Do we need to create new network?
+          unless @interface_network[:created]
+            @interface_network[:name] = @options[:network_name]
+
+            # Generate a unique name for network bridge.
+            @interface_network[:bridge_name] = generate_bridge_name
+
+            # Create a private network.
+            create_private_network(env)
+          end
+        end
+
+        def handle_dhcp_private_network(env)
+          net_address = '172.28.128.0'
+          network = lookup_network_by_ip(net_address)
+          @interface_network = network if network
+
+          # Do we need to create new network?
+          unless @interface_network[:created]
+            @interface_network[:name] = 'vagrant-private-dhcp'
+            @interface_network[:network_address] = net_address
+
+            # Set IP address of network (actually bridge). It will be used as
+            # gateway address for machines connected to this network.
+            @interface_network[:ip_address] = get_host_ip_addr(net_address)
+
+            # Generate a unique name for network bridge.
+            @interface_network[:bridge_name] = generate_bridge_name
+
+            # Create a private network.
+            create_private_network(env)
+          end
+        end
+
+        # Return provided address or first address of network otherwise
+        def get_host_ip_addr(network)
+          @options[:host_ip] ? IPAddr.new(@options[:host_ip]) : IPAddr.new(network).succ
+        end
+
+        # Return the first available virbr interface name
+        def generate_bridge_name
+          @logger.debug "generating name for bridge"
+          count = 0
+          while lookup_bridge_by_name(bridge_name = "virbr#{count}")
+            count += 1
+          end
+          @logger.debug "found available bridge name #{bridge_name}"
+          bridge_name
         end
 
         def create_private_network(env)
@@ -235,7 +280,7 @@ module VagrantPlugins
             # Find out DHCP addresses pool range.
             network_address = "#{@interface_network[:network_address]}/"
             network_address << "#{@interface_network[:netmask]}"
-            net = IPAddr.new(network_address)
+            net = @interface_network[:network_address] ? IPAddr.new(network_address) : nil
 
             # First is address of network, second is gateway (by default).
             # So start the range two addresses after network address by default.