vagrant-libvirt 0.0.41 → 0.0.42

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

@@ -0,0 +1,20 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      class RemoveLibvirtImage
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::remove_libvirt_image')
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info('Vagrant-libvirt plugin removed box only from you LOCAL ~/.vagrant/boxes directory')
+          env[:ui].info('From libvirt storage pool you have to delete image manually(virsh, virt-manager or by any other tool)')
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'log4r'
+# require 'log4r/yamlconfigurator'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      class RemoveStaleVolume
+        def initialize(app, _env)
+          #          log4r_config= YAML.load_file(File.join(File.dirname(__FILE__),"log4r.yaml"))
+          #          log_cfg = Log4r::YamlConfigurator
+          #          log_cfg.decode_yaml( log4r_config['log4r_config'] )
+
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::remove_stale_volume')
+          @app = app
+        end
+
+        def call(env)
+          # Remove stale server volume
+          env[:ui].info(I18n.t('vagrant_libvirt.remove_stale_volume'))
+
+          config = env[:machine].provider_config
+          # Check for storage pool, where box image should be created
+          fog_pool = ProviderLibvirt::Util::Collection.find_matching(
+            env[:machine].provider.driver.connection.pools.all, config.storage_pool_name
+          )
+          @logger.debug("**** Pool #{fog_pool.name}")
+
+          # This is name of newly created image for vm.
+          name = "#{env[:domain_name]}.img"
+          @logger.debug("**** Volume name #{name}")
+
+          # remove root storage
+          box_volume = ProviderLibvirt::Util::Collection.find_matching(
+            env[:machine].provider.driver.connection.volumes.all, name
+          )
+          if box_volume && box_volume.pool_name == fog_pool.name
+            @logger.info("Deleting volume #{box_volume.key}")
+            box_volume.destroy
+            env[:result] = box_volume
+          else
+            env[:result] = nil
+          end
+
+          # Continue the middleware chain.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Resume suspended domain.
+      class ResumeDomain
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::resume_domain')
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_libvirt.resuming_domain'))
+
+          domain = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
+          raise Errors::NoDomainError if domain.nil?
+
+          libvirt_domain = env[:machine].provider.driver.connection.client.lookup_domain_by_uuid(env[:machine].id)
+          config = env[:machine].provider_config
+          if config.suspend_mode == 'managedsave'
+            domain.start
+          else
+            domain.resume
+          end
+
+          @logger.info("Machine #{env[:machine].id} is resumed.")
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+require 'log4r'
+require 'nokogiri'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # boot order useful for pxe in discovery workflow
+      class SetBootOrder
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::set_boot_order')
+          config = env[:machine].provider_config
+          @boot_order = config.boot_order
+        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
+
+          # Only execute specific boot ordering if this is defined
+          # in the Vagrant file
+          if @boot_order.count >= 1
+
+            # If a domain is initially defined with no box or disk or
+            # with an explicit boot order, libvirt adds <boot dev="foo">
+            # This conflicts with an explicit boot_order configuration,
+            # so we need to remove it from the domain xml and feed it back.
+            # Also see https://bugzilla.redhat.com/show_bug.cgi?id=1248514
+            # as to why we have to do this after all devices have been defined.
+            xml = Nokogiri::XML(domain.xml_desc)
+            xml.search('/domain/os/boot').each(&:remove)
+
+            # Parse the XML and find each defined drive and network interfacee
+            hd = xml.search("/domain/devices/disk[@device='disk']")
+            cdrom = xml.search("/domain/devices/disk[@device='cdrom']")
+            # implemented only for 1 network
+            nets = @boot_order.flat_map do |x|
+              x.class == Hash ? x : nil
+            end.compact
+            raise 'Defined only for 1 network for boot' if nets.size > 1
+            network = search_network(nets, xml)
+
+            # Generate an array per device group and a flattened
+            # array from all of those
+            devices = { 'hd' => hd,
+                        'cdrom' => cdrom,
+                        'network' => network }
+
+            final_boot_order = final_boot_order(@boot_order, devices)
+            # Loop over the entire defined boot order array and
+            # create boot order entries in the domain XML
+            final_boot_order.each_with_index do |node, index|
+              boot = "<boot order='#{index + 1}'/>"
+              node.add_child(boot)
+              logger_msg(node, index)
+            end
+
+            # Finally redefine the domain XML through libvirt
+            # to apply the boot ordering
+            env[:machine].provider
+                         .driver
+                         .connection
+                         .client
+                         .define_domain_xml(xml.to_s)
+          end
+
+          @app.call(env)
+        end
+
+        def final_boot_order(boot_order, devices)
+          boot_order.flat_map do |category|
+            devices[category.class == Hash ? category.keys.first : category]
+          end
+        end
+
+        def search_network(nets, xml)
+          str = '/domain/devices/interface'
+          str += "[(@type='network' or @type='udp' or @type='bridge')"
+          unless nets.empty?
+            str += " and source[@network='#{nets.first['network']}']"
+          end
+          str += ']'
+          @logger.debug(str)
+          xml.search(str)
+        end
+
+        def logger_msg(node, index)
+          name = if node.name == 'disk'
+                   node['device']
+                 elsif node.name == 'interface'
+                   node.name
+                 end
+          @logger.debug "Setting #{name} to boot index #{index + 1}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'securerandom'
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Setup name for domain and domain volumes.
+      class SetNameOfDomain
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::set_name_of_domain')
+          @app    = app
+        end
+
+        def call(env)
+          env[:domain_name] = build_domain_name(env)
+
+          begin
+            @logger.info("Looking for domain #{env[:domain_name]} through list " \
+                         "#{env[:machine].provider.driver.connection.servers.all}")
+            # Check if the domain name is not already taken
+
+            domain = ProviderLibvirt::Util::Collection.find_matching(
+              env[:machine].provider.driver.connection.servers.all, env[:domain_name]
+            )
+          rescue Fog::Errors::Error => e
+            @logger.info(e.to_s)
+            domain = nil
+          end
+
+          @logger.info("Looking for domain #{env[:domain_name]}")
+
+          unless domain.nil?
+            raise ProviderLibvirt::Errors::DomainNameExists,
+                  domain_name: env[:domain_name]
+          end
+
+          @app.call(env)
+        end
+
+        # build domain name
+        # random_hostname option avoids
+        # `domain about to create is already taken`
+        # parsable and sortable by epoch time
+        # @example
+        #   development-centos-6-chef-11_1404488971_3b7a569e2fd7c554b852
+        # @return [String] libvirt domain name
+        def build_domain_name(env)
+          config = env[:machine].provider_config
+          domain_name =
+            if config.default_prefix.nil?
+              env[:root_path].basename.to_s.dup.concat('_')
+            elsif config.default_prefix.empty?
+              # don't have any prefix, not even "_"
+              ''
+            else
+              config.default_prefix.to_s.dup.concat('_')
+            end
+          domain_name << env[:machine].name.to_s
+          domain_name.gsub!(/[^-a-z0-9_\.]/i, '')
+          domain_name << "_#{Time.now.utc.to_i}_#{SecureRandom.hex(10)}" if config.random_hostname
+          domain_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'pathname'
+
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      class ShareFolders
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant::action::vm::share_folders')
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          prepare_folders
+          create_metadata
+
+          @app.call(env)
+        end
+
+        # This method returns an actual list of shared
+        # folders to create and their proper path.
+        def shared_folders
+          {}.tap do |result|
+            @env[:machine].config.vm.synced_folders.each do |id, data|
+              # Ignore NFS shared folders
+              next if !data[:type] == :nfs
+
+              # This to prevent overwriting the actual shared folders data
+              result[id] = data.dup
+            end
+          end
+        end
+
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |_id, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            next unless !hostpath.directory? && options[:create]
+            # Host path doesn't exist, so let's create it.
+            @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+            begin
+              hostpath.mkpath
+            rescue Errno::EACCES
+              raise Vagrant::Errors::SharedFolderCreateFailed,
+                    path: hostpath.to_s
+            end
+          end
+        end
+
+        def create_metadata
+          @env[:ui].info I18n.t('vagrant.actions.vm.share_folders.creating')
+
+          folders = []
+          shared_folders.each do |id, data|
+            folders << {
+              name: id,
+              hostpath: File.expand_path(data[:hostpath], @env[:root_path]),
+              transient: data[:transient]
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,307 @@
+require 'log4r'
+require 'rexml/document'
+
+module VagrantPlugins
+  module ProviderLibvirt
+    module Action
+      # Just start the domain.
+      class StartDomain
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_libvirt::action::start_domain')
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_libvirt.starting_domain'))
+
+          domain = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
+          raise Errors::NoDomainError if domain.nil?
+          config = env[:machine].provider_config
+
+          begin
+            # update domain settings on change.
+
+            libvirt_domain = env[:machine].provider.driver.connection.client.lookup_domain_by_uuid(env[:machine].id)
+
+            # libvirt API doesn't support modifying memory on NUMA enabled CPUs
+            # http://libvirt.org/git/?p=libvirt.git;a=commit;h=d174394105cf00ed266bf729ddf461c21637c736
+            if config.numa_nodes == nil
+              if config.memory.to_i * 1024 != libvirt_domain.max_memory
+                libvirt_domain.max_memory = config.memory.to_i * 1024
+                libvirt_domain.memory = libvirt_domain.max_memory
+              end
+            end
+            begin
+              # XML definition manipulation
+              descr = libvirt_domain.xml_desc(1)
+              xml_descr = REXML::Document.new descr
+              descr_changed = false
+
+              # additional disk bus
+              config.disks.each do |disk|
+                device = disk[:device]
+                bus = disk[:bus]
+                REXML::XPath.each(xml_descr, '/domain/devices/disk[@device="disk"]/target[@dev="' + device + '"]') do |disk_target|
+                  next unless disk_target.attributes['bus'] != bus
+                  descr_changed = true
+                  disk_target.attributes['bus'] = bus
+                  disk_target.parent.delete_element("#{disk_target.parent.xpath}/address")
+                end
+              end
+
+              # disk_bus
+              REXML::XPath.each(xml_descr, '/domain/devices/disk[@device="disk"]/target[@dev="vda"]') do |disk_target|
+                next unless disk_target.attributes['bus'] != config.disk_bus
+                descr_changed = true
+                disk_target.attributes['bus'] = config.disk_bus
+                disk_target.parent.delete_element("#{disk_target.parent.xpath}/address")
+              end
+
+              # Iterface type
+              unless config.nic_model_type.nil?
+                REXML::XPath.each(xml_descr, '/domain/devices/interface/model') do |iface_model|
+                  if iface_model.attributes['type'] != config.nic_model_type
+                    descr_changed = true
+                    iface_model.attributes['type'] = config.nic_model_type
+                  end
+                end
+              end
+
+              # vCpu count
+              if config.cpus.to_i != libvirt_domain.vcpus.length
+                descr_changed = true
+                REXML::XPath.first(xml_descr, '/domain/vcpu').text = config.cpus
+              end
+
+              # cpu_mode
+              cpu = REXML::XPath.first(xml_descr, '/domain/cpu')
+              if cpu.nil?
+                descr_changed = true
+                cpu = REXML::Element.new('cpu', REXML::XPath.first(xml_descr, '/domain'))
+                cpu.attributes['mode'] = config.cpu_mode
+              else
+                if cpu.attributes['mode'] != config.cpu_mode
+                  descr_changed = true
+                  cpu.attributes['mode'] = config.cpu_mode
+                end
+              end
+
+              if config.cpu_mode != 'host-passthrough'
+                cpu_model = REXML::XPath.first(xml_descr, '/domain/cpu/model')
+                if cpu_model.nil?
+                  descr_changed = true
+                  cpu_model = REXML::Element.new('model', REXML::XPath.first(xml_descr, '/domain/cpu'))
+                  cpu_model.attributes['fallback'] = 'allow'
+                  cpu_model.text = config.cpu_model
+                else
+                  if cpu_model.text != config.cpu_model
+                    descr_changed = true
+                    cpu_model.text = config.cpu_model
+                  end
+                  if cpu_model.attributes['fallback'] != config.cpu_fallback
+                    descr_changed = true
+                    cpu_model.attributes['fallback'] = config.cpu_fallback
+                  end
+                end
+                vmx_feature = REXML::XPath.first(xml_descr, '/domain/cpu/feature[@name="vmx"]')
+                svm_feature = REXML::XPath.first(xml_descr, '/domain/cpu/feature[@name="svm"]')
+                if config.nested
+                  if vmx_feature.nil?
+                    descr_changed = true
+                    vmx_feature = REXML::Element.new('feature', REXML::XPath.first(xml_descr, '/domain/cpu'))
+                    vmx_feature.attributes['policy'] = 'optional'
+                    vmx_feature.attributes['name'] = 'vmx'
+                  end
+                  if svm_feature.nil?
+                    descr_changed = true
+                    svm_feature = REXML::Element.new('feature', REXML::XPath.first(xml_descr, '/domain/cpu'))
+                    svm_feature.attributes['policy'] = 'optional'
+                    svm_feature.attributes['name'] = 'svm'
+                  end
+                else
+                  unless vmx_feature.nil?
+                    descr_changed = true
+                    cpu.delete_element(vmx_feature)
+                  end
+                  unless svm_feature.nil?
+                    descr_changed = true
+                    cpu.delete_element(svm_feature)
+                  end
+                end
+              elsif config.numa_nodes == nil
+                unless cpu.elements.to_a.empty?
+                  descr_changed = true
+                  cpu.elements.each do |elem|
+                    cpu.delete_element(elem)
+                  end
+                end
+              end
+
+              # Graphics
+              graphics = REXML::XPath.first(xml_descr, '/domain/devices/graphics')
+              if config.graphics_type != 'none'
+                if graphics.nil?
+                  descr_changed = true
+                  graphics = REXML::Element.new('graphics', REXML::XPath.first(xml_descr, '/domain/devices'))
+                end
+                if graphics.attributes['type'] != config.graphics_type
+                  descr_changed = true
+                  graphics.attributes['type'] = config.graphics_type
+                end
+                if graphics.attributes['listen'] != config.graphics_ip
+                  descr_changed = true
+                  graphics.attributes['listen'] = config.graphics_ip
+                  graphics.delete_element('//listen')
+                end
+                if graphics.attributes['autoport'] != config.graphics_autoport
+                  descr_changed = true
+                  graphics.attributes['autoport'] = config.graphics_autoport
+                  if config.graphics_autoport == 'no'
+                    graphics.attributes['port'] = config.graphics_port
+                  end
+                end
+                if graphics.attributes['keymap'] != config.keymap
+                  descr_changed = true
+                  graphics.attributes['keymap'] = config.keymap
+                end
+                if graphics.attributes['passwd'] != config.graphics_passwd
+                  descr_changed = true
+                  if config.graphics_passwd.nil?
+                    graphics.attributes.delete 'passwd'
+                  else
+                    graphics.attributes['passwd'] = config.graphics_passwd
+                  end
+                end
+              else
+                # graphics_type = none, remove entire element
+                graphics.parent.delete_element(graphics) unless graphics.nil?
+              end
+
+              # TPM
+              if config.tpm_path
+                raise Errors::FogCreateServerError, 'The TPM Path must be fully qualified' unless config.tpm_path[0].chr == '/'
+
+                tpm = REXML::XPath.first(xml_descr, '/domain/devices/tpm')
+                if tpm.nil?
+                  descr_changed = true
+                  tpm = REXML::Element.new('tpm', REXML::XPath.first(xml_descr, '/domain/devices/tpm/model'))
+                  tpm.attributes['model'] = config.tpm_model
+                  tpm_backend_type = tpm.add_element('backend')
+                  tpm_backend_type.attributes['type'] = config.tpm_type
+                  tpm_device_path = tpm_backend_type.add_element('device')
+                  tpm_device_path.attributes['path'] = config.tpm_path
+                else
+                  if tpm.attributes['model'] != config.tpm_model
+                    descr_changed = true
+                    tpm.attributes['model'] = config.tpm_model
+                  end
+                  if tpm.elements['backend'].attributes['type'] != config.tpm_type
+                    descr_changed = true
+                    tpm.elements['backend'].attributes['type'] = config.tpm_type
+                  end
+                  if tpm.elements['backend'].elements['device'].attributes['path'] != config.tpm_path
+                    descr_changed = true
+                    tpm.elements['backend'].elements['device'].attributes['path'] = config.tpm_path
+                  end
+                end
+              end
+
+              # Video device
+              video = REXML::XPath.first(xml_descr, '/domain/devices/video')
+              if !video.nil? && (config.graphics_type == 'none')
+                # graphics_type = none, video devices are removed since there is no possible output
+                descr_changed = true
+                video.parent.delete_element(video)
+              else
+                video_model = REXML::XPath.first(xml_descr, '/domain/devices/video/model')
+                if video_model.nil?
+                  video_model = REXML::Element.new('model', REXML::XPath.first(xml_descr, '/domain/devices/video'))
+                  video_model.attributes['type'] = config.video_type
+                  video_model.attributes['vram'] = config.video_vram
+                else
+                  if video_model.attributes['type'] != config.video_type || video_model.attributes['vram'] != config.video_vram
+                    descr_changed = true
+                    video_model.attributes['type'] = config.video_type
+                    video_model.attributes['vram'] = config.video_vram
+                  end
+                end
+              end
+
+              # Sound device
+              if config.sound_type
+                sound = REXML::XPath.first(xml_descr,'/domain/devices/sound/model')
+              end
+
+
+              # dtb
+              if config.dtb
+                dtb = REXML::XPath.first(xml_descr, '/domain/os/dtb')
+                if dtb.nil?
+                  descr_changed = true
+                  dtb = REXML::Element.new('dtb', REXML::XPath.first(xml_descr, '/domain/os'))
+                  dtb.text = config.dtb
+                else
+                  if dtb.text != config.dtb
+                    descr_changed = true
+                    dtb.text = config.dtb
+                  end
+                end
+              end
+
+              # kernel and initrd
+              if config.kernel
+                kernel = REXML::XPath.first(xml_descr, '/domain/os/kernel')
+                if kernel.nil?
+                  descr_changed = true
+                  kernel = REXML::Element.new('kernel', REXML::XPath.first(xml_descr, '/domain/os'))
+                  kernel.text = config.kernel
+                else
+                  if kernel.text != config.kernel
+                    descr_changed = true
+                    kernel.text = config.kernel
+                  end
+                end
+              end
+              if config.initrd
+                initrd = REXML::XPath.first(xml_descr, '/domain/os/initrd')
+                if initrd.nil?
+                  descr_changed = true
+                  initrd = REXML::Element.new('initrd', REXML::XPath.first(xml_descr, '/domain/os'))
+                  initrd.text = config.initrd
+                else
+                  if initrd.text != config.initrd
+                    descr_changed = true
+                    initrd.text = config.initrd
+                  end
+                end
+              end
+
+              # Apply
+              if descr_changed
+                begin
+                  libvirt_domain.undefine
+                  new_descr = ''
+                  xml_descr.write new_descr
+                  server = env[:machine].provider.driver.connection.servers.create(xml: new_descr)
+                rescue Fog::Errors::Error => e
+                  server = env[:machine].provider.driver.connection.servers.create(xml: descr)
+                  raise Errors::FogCreateServerError, error_message: e.message
+                end
+              end
+            rescue => e
+              env[:ui].error("Error when updating domain settings: #{e.message}")
+            end
+            # Autostart with host if enabled in Vagrantfile
+            libvirt_domain.autostart = config.autostart
+            # Actually start the domain
+            domain.start
+          rescue => e
+            raise Errors::FogError, message: e.message
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end