vagrant-libvirt 0.0.40 → 0.0.41

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

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

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

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

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

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

@@ -1,303 +0,0 @@
-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)
-
-            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
-            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
-              else
-                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