vagrant-libvirt 0.0.40 → 0.0.41

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

@@ -1,353 +0,0 @@
-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,
-                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 = '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)
-          @network_name = @interface_network[:name]
-          @network_bridge_name = @interface_network[:bridge_name]
-          @network_address = @interface_network[:ip_address]
-          @network_netmask = @interface_network[:netmask]
-          @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
-
-          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

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

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