vagrant-libvirt 0.0.41 → 0.0.42

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

@@ -0,0 +1,361 @@
+require 'log4r'
+require 'vagrant/util/network_ip'
+require 'vagrant/util/scoped_hash_override'
+require 'ipaddr'
+require 'thread'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Prepare all networks needed for domain connections.
+      class CreateNetworks
+        include Vagrant::Util::NetworkIP
+        include Vagrant::Util::ScopedHashOverride
+        include VagrantPlugins::ProviderLibvirt::Util::ErbTemplate
+        include VagrantPlugins::ProviderLibvirt::Util::NetworkUtil
+
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          mess = 'vagrant_libvirt::action::create_networks'
+          @logger = Log4r::Logger.new(mess)
+          @app = app
+
+          @available_networks = []
+          @options = {}
+          @libvirt_client = env[:machine].provider.driver.connection.client
+        end
+
+        def call(env)
+          # only one vm at a time should try to set up networks
+          # otherwise they'll have inconsitent views of current state
+          # and conduct redundant operations that cause errors
+          @@lock.synchronize do
+            # Iterate over networks If some network is not
+            # 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 ||
+                      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
+              @options = options
+
+              # Get a list of all (active and inactive) libvirt networks. This
+              # list is used throughout this class and should be easier to
+              # process than libvirt API calls.
+              @available_networks = libvirt_networks(
+                env[:machine].provider.driver.connection.client
+              )
+
+              # Prepare a hash describing network for this specific interface.
+              @interface_network = {
+                name:             nil,
+                ip_address:       nil,
+                netmask:          @options[:netmask],
+                network_address:  nil,
+                bridge_name:      nil,
+                domain_name:      nil,
+                ipv6_address:     options[:ipv6_address] || nil,
+                ipv6_prefix:      options[:ipv6_prefix] || nil,
+                created:          false,
+                active:           false,
+                autostart:        options[:autostart] || false,
+                guest_ipv6:       @options[:guest_ipv6] || 'yes',
+                libvirt_network:  nil
+              }
+
+              if @options[:ip]
+                handle_ip_option(env)
+              elsif @options[:type].to_s == 'dhcp'
+                handle_dhcp_private_network(env)
+              elsif @options[:network_name]
+                handle_network_name_option(env)
+              else
+                raise Errors::CreateNetworkError, error_message: @options
+              end
+
+              autostart_network if @interface_network[:autostart]
+              activate_network unless @interface_network[:active]
+            end
+          end
+
+          @app.call(env)
+        end
+
+        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.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.find { |network| network[:bridge_name] == bridge_name }
+        end
+
+        # Throw an error if dhcp setting for an existing network does not
+        # match what was configured in the vagrantfile
+        # since we always enable dhcp for the management network
+        # this ensures we wont start a vm vagrant cant reach
+        # Allow the situation where DHCP is not requested (:libvirt__dhcp_enabled == false)
+        # but where it is enabled on the virtual network
+        def verify_dhcp
+          if @interface_network[:dhcp_enabled] == true && @options[:dhcp_enabled] == false
+            raise Errors::DHCPMismatch,
+                  network_name: @interface_network[:name],
+                  requested: @options[:dhcp_enabled] ? 'enabled' : 'disabled'
+          end
+        end
+
+        # 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 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
+
+          @interface_network[:network_address] = net_address
+
+          # if network is veryisolated, search by name
+          network = if @options[:libvirt__forward_mode] == 'veryisolated'
+                      lookup_network_by_name(@options[:network_name])
+                    elsif net_address
+                      # otherwise, search by ip (if set)
+                      lookup_network_by_ip(net_address)
+                    else
+                      # leaving this here to mimic prior behavior. If we get
+                      # here, something's probably broken.
+                      lookup_network_by_name(@options[:network_name])
+                    end
+          @interface_network = network if network
+
+          verify_dhcp if @interface_network[:created]
+
+          if @options[:network_name]
+            @logger.debug 'Checking that network name does not clash with ip'
+            if @interface_network[:created]
+              # Just check for mismatch error here - if name and ip from
+              # config match together.
+              if @options[:network_name] != @interface_network[:name]
+                raise Errors::NetworkNameAndAddressMismatch,
+                      ip_address:   @options[:ip],
+                      network_name: @options[:network_name]
+              end
+            else
+              # Network is not created, but name is set. We need to check,
+              # whether network name from config doesn't already exist.
+              if lookup_network_by_name @options[:network_name]
+                raise Errors::NetworkNameAndAddressMismatch,
+                      ip_address:   @options[:ip],
+                      network_name: @options[:network_name]
+              end
+
+              # Network with 'name' doesn't exist. Set it as name for new
+              # network.
+              @interface_network[:name] = @options[:network_name]
+            end
+          end
+
+          # Do we need to create new network?
+          unless @interface_network[:created]
+
+            # TODO: stop after some loops. Don't create infinite loops.
+
+            # Is name for new network set? If not, generate a unique one.
+            count = 0
+            while @interface_network[:name].nil?
+              @logger.debug 'generating name for network'
+
+              # Generate a network name.
+              network_name = env[:root_path].basename.to_s.dup
+              network_name << count.to_s
+              count += 1
+
+              # Check if network name is unique.
+              next if lookup_network_by_name(network_name)
+
+              @interface_network[:name] = network_name
+            end
+
+            # Generate a unique name for network bridge.
+            @interface_network[:bridge_name] = generate_bridge_name
+
+            # Create a private network.
+            create_private_network(env)
+          end
+        end
+
+        # 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(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
+
+          if @options[:libvirt__forward_mode] == 'veryisolated'
+            # if this interface has a network address, something's wrong.
+            if @interface_network[:network_address]
+              raise Errors::NetworkNotAvailableError,
+                    network_name: @options[:network_name]
+            end
+          else
+            if !@interface_network
+              raise Errors::NetworkNotAvailableError,
+                    network_name: @options[:network_name]
+            else
+              verify_dhcp
+            end
+          end
+
+          # Do we need to create new network?
+          unless @interface_network[:created]
+            @interface_network[:name] = @options[:network_name]
+            @interface_network[:ip_address] ||= @options[:host_ip]
+
+            # 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 = @options[:libvirt__network_address]
+          net_address = '172.28.128.0' unless net_address
+          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)
+          @network_name = @interface_network[:name]
+          @network_bridge_name = @interface_network[:bridge_name]
+          @network_address = @interface_network[:ip_address]
+          @network_netmask = @interface_network[:netmask]
+          @network_mtu = Integer(@options[:mtu]) if @options[:mtu]
+
+          @guest_ipv6 = @interface_network[:guest_ipv6]
+
+          @network_ipv6_address = @interface_network[:ipv6_address]
+          @network_ipv6_prefix = @interface_network[:ipv6_prefix]
+
+          @network_forward_mode = @options[:forward_mode]
+          if @options[:forward_device]
+            @network_forward_device = @options[:forward_device]
+          end
+
+          if @options[:dhcp_enabled]
+            # Find out DHCP addresses pool range.
+            network_address = "#{@interface_network[:network_address]}/"
+            network_address << (@interface_network[:netmask]).to_s
+            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.
+            # TODO: Detect if this IP is not set on the interface.
+            start_address = @options[:dhcp_start] || net.to_range.begin.succ
+
+            # Default to last possible address. (Stop address must not be broadcast address.)
+            stop_address = @options[:dhcp_stop] || (net.to_range.end & IPAddr.new('255.255.255.254'))
+
+            @network_dhcp_enabled = true
+            @network_dhcp_bootp_file = @options[:dhcp_bootp_file]
+            @network_dhcp_bootp_server = @options[:dhcp_bootp_server]
+            @network_range_start = start_address
+            @network_range_stop = stop_address
+          else
+            @network_dhcp_enabled = false
+          end
+
+          @network_domain_name = @options[:domain_name]
+
+          begin
+            @interface_network[:libvirt_network] = \
+              @libvirt_client.define_network_xml(to_xml('private_network'))
+            @logger.debug 'created network'
+          rescue => e
+            raise Errors::CreateNetworkError, error_message: e.message
+          end
+
+          created_networks_file = env[:machine].data_dir + 'created_networks'
+
+          message = 'Saving information about created network '
+          message << "#{@interface_network[:name]}, "
+          message << "UUID=#{@interface_network[:libvirt_network].uuid} "
+          message << "to file #{created_networks_file}."
+          @logger.info(message)
+
+          File.open(created_networks_file, 'a') do |file|
+            file.puts @interface_network[:libvirt_network].uuid
+          end
+        end
+
+        def autostart_network
+          @interface_network[:libvirt_network].autostart = true
+        rescue => e
+          raise Errors::AutostartNetworkError, error_message: e.message
+        end
+
+        def activate_network
+          @interface_network[:libvirt_network].create
+        rescue => e
+          raise Errors::ActivateNetworkError, error_message: e.message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      class DestroyDomain
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::destroy_domain')
+          @app = app
+        end
+
+        def call(env)
+          # Destroy the server, remove the tracking ID
+          env[:ui].info(I18n.t('vagrant_libvirt.destroy_domain'))
+
+          # Must delete any snapshots before domain can be destroyed
+          # Fog libvirt currently doesn't support snapshots. Use
+          # ruby-libvirt client directly. Note this is racy, see
+          # http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotListNames
+          libvirt_domain = env[:machine].provider.driver.connection.client.lookup_domain_by_uuid(
+            env[:machine].id
+          )
+          begin
+            libvirt_domain.list_snapshots.each do |name|
+              @logger.info("Deleting snapshot '#{name}'")
+              begin
+                libvirt_domain.lookup_snapshot_by_name(name).delete
+              rescue => e
+                raise Errors::DeleteSnapshotError, error_message: e.message
+              end
+            end
+          rescue
+            # Some drivers (xen) don't support getting list of snapshots,
+            # not much can be done here about it
+            @logger.warn("Failed to get list of snapshots")
+          end
+
+          # must remove managed saves
+          libvirt_domain.managed_save_remove if libvirt_domain.has_managed_save?
+
+          domain = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
+
+          if env[:machine].provider_config.disks.empty? &&
+             env[:machine].provider_config.cdroms.empty?
+            # if using default configuration of disks and cdroms
+            # cdroms are consider volumes, but cannot be destroyed
+            domain.destroy(destroy_volumes: true)
+          else
+            domain.destroy(destroy_volumes: false)
+
+            env[:machine].provider_config.disks.each do |disk|
+              # shared disks remove only manually or ???
+              next if disk[:allow_existing]
+              diskname = libvirt_domain.name + '-' + disk[:device] + '.' + disk[:type].to_s
+              # diskname is unique
+              libvirt_disk = domain.volumes.select do |x|
+                x.name == diskname
+              end.first
+              if libvirt_disk
+                libvirt_disk.destroy
+              elsif disk[:path]
+                poolname = env[:machine].provider_config.storage_pool_name
+                libvirt_disk = domain.volumes.select do |x|
+                  # FIXME: can remove pool/target.img and pool/123/target.img
+                  x.path =~ /\/#{disk[:path]}$/ && x.pool_name == poolname
+                end.first
+                libvirt_disk.destroy if libvirt_disk
+              end
+            end
+
+            # remove root storage
+            root_disk = domain.volumes.select do |x|
+              x.name == libvirt_domain.name + '.img'
+            end.first
+            root_disk.destroy if root_disk
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require 'log4r'
+require 'nokogiri'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Destroy all networks created for this specific domain. Skip
+      # removing if network has still active connections.
+      class DestroyNetworks
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::destroy_networks')
+          @app = app
+        end
+
+        def call(env)
+          # If there were some networks created for this machine, in machines
+          # data directory, created_networks file holds UUIDs of each network.
+          created_networks_file = env[:machine].data_dir + 'created_networks'
+
+          @logger.info 'Checking if any networks were created'
+          # If created_networks file doesn't exist, there are no networks we
+          # need to remove.
+          unless File.exist?(created_networks_file)
+            env[:machine].id = nil
+            return @app.call(env)
+          end
+
+          @logger.info 'File with created networks exists'
+
+          # Iterate over each created network UUID and try to remove it.
+          created_networks = []
+          file = File.open(created_networks_file, 'r')
+          file.readlines.each do |network_uuid|
+            @logger.info "Checking for #{network_uuid}"
+            # lookup_network_by_uuid throws same exception
+            # if there is an error or if the network just doesn't exist
+            begin
+              libvirt_network = env[:machine].provider.driver.connection.client.lookup_network_by_uuid(
+                network_uuid
+              )
+            rescue Libvirt::RetrieveError => e
+              # this network is already destroyed, so move on
+              if e.message =~ /Network not found/
+                @logger.info 'It is already undefined'
+                next
+              # some other error occured, so raise it again
+              else
+                raise e
+              end
+            end
+
+            # Skip removing if network has still active connections.
+            xml = Nokogiri::XML(libvirt_network.xml_desc)
+            connections = xml.xpath('/network/@connections').first
+            unless connections.nil?
+              @logger.info 'Still has connections so will not undefine'
+              created_networks << network_uuid
+              next
+            end
+
+            # Shutdown network first.
+            # Undefine network.
+            begin
+              libvirt_network.destroy
+              libvirt_network.undefine
+              @logger.info 'Undefined it'
+            rescue => e
+              raise Errors::DestroyNetworkError,
+                    network_name: libvirt_network.name,
+                    error_message: e.message
+            end
+          end
+          file.close
+
+          # Update status of created networks after removing some/all of them.
+          # Not sure why we are doing this, something else seems to always delete the file
+          if !created_networks.empty?
+            File.open(created_networks_file, 'w') do |file|
+              @logger.info 'Writing new created_networks file'
+              created_networks.each do |network_uuid|
+                file.puts network_uuid
+              end
+            end
+          else
+            @logger.info 'Deleting created_networks file'
+            File.delete(created_networks_file)
+          end
+
+          env[:machine].id = nil
+          @app.call(env)
+        end
+      end
+    end
+  end
+end