vagrant-libvirt 0.4.0 → 0.5.3

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

@@ -13,24 +13,40 @@ module VagrantPlugins
         def call(env)
           env[:ui].info(I18n.t('vagrant_libvirt.halt_domain'))
 
+          timeout = env[:machine].config.vm.graceful_halt_timeout
           domain = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
           raise Errors::NoDomainError if domain.nil?
 
-          begin
-            env[:machine].guest.capability(:halt)
-          rescue
-            @logger.info('Trying Libvirt graceful shutdown.')
-            domain.shutdown
+          if env[:force_halt]
+            domain.poweroff
+            return @app.call(env)
           end
 
-
           begin
-            domain.wait_for(30) do
-              !ready?
+            Timeout.timeout(timeout) do
+              begin
+                env[:machine].guest.capability(:halt)
+              rescue Timeout::Error
+                raise
+              rescue
+                @logger.info('Trying Libvirt graceful shutdown.')
+                # Read domain object again
+                dom = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
+                if dom.state.to_s == 'running'
+                  dom.shutdown
+                end
+              end
+
+              domain.wait_for(timeout) do
+                !ready?
+              end
             end
-          rescue Fog::Errors::TimeoutError
+          rescue Timeout::Error
             @logger.info('VM is still running. Calling force poweroff.')
             domain.poweroff
+          rescue
+            @logger.error('Failed to shutdown cleanly. Calling force poweroff.')
+            domain.poweroff
           end
 
           @app.call(env)

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

@@ -1,4 +1,8 @@
 require 'log4r'
+require 'open3'
+require 'json'
+
+require 'vagrant-libvirt/util/byte_number'
 
 module VagrantPlugins
   module ProviderLibvirt
@@ -16,118 +20,207 @@ module VagrantPlugins
         end
 
         def call(env)
-          # Verify box metadata for mandatory values.
-          #
-          # Virtual size has to be set for allocating space in storage pool.
-          box_virtual_size = env[:machine].box.metadata['virtual_size']
-          raise Errors::NoBoxVirtualSizeSet if box_virtual_size.nil?
+          # Handle box formats converting between v1 => v2 and ensuring
+          # any obsolete settings are rejected.
 
-          # Support qcow2 format only for now, but other formats with backing
-          # store capability should be usable.
-          box_format = env[:machine].box.metadata['format']
-          if box_format.nil?
-            raise Errors::NoBoxFormatSet
-          elsif box_format != 'qcow2'
-            raise Errors::WrongBoxFormatSet
+          disks = env[:machine].box.metadata.fetch('disks', [])
+          if disks.empty?
+            # Handle box v1 format
+
+            # Only qcow2 format is supported in v1, but other formats with backing
+            # store capability should be usable.
+            box_format = env[:machine].box.metadata['format']
+            HandleBoxImage.verify_box_format(box_format)
+
+            env[:box_volume_number] = 1
+            env[:box_volumes] = [{
+              :path => HandleBoxImage.get_box_image_path(env[:machine].box, 'box.img'),
+              :name => HandleBoxImage.get_volume_name(env[:machine].box, 'box'),
+              :virtual_size => HandleBoxImage.get_virtual_size(env),
+              :format => box_format,
+            }]
+          else
+            # Handle box v2 format
+            # {
+            #   'path': '<path-of-file-box>',
+            #   'name': '<name-to-use-in-storage>' # optional, will use index
+            # }
+            #
+            env[:box_volume_number] = disks.length()
+            target_volumes = Hash[]
+            env[:box_volumes] = Array.new(env[:box_volume_number]) { |i|
+              raise Errors::BoxFormatMissingAttribute, attribute: "disks[#{i}]['path']" if disks[i]['path'].nil?
+
+              image_path = HandleBoxImage.get_box_image_path(env[:machine].box, disks[i]['path'])
+              format, virtual_size = HandleBoxImage.get_box_disk_settings(image_path)
+              volume_name = HandleBoxImage.get_volume_name(
+                env[:machine].box,
+                disks[i].fetch('name', disks[i]['path'].sub(/#{File.extname(disks[i]['path'])}$/, '')),
+              )
+
+              # allowing name means needing to check that it doesn't cause a clash
+              existing = target_volumes[volume_name]
+              if !existing.nil?
+                raise Errors::BoxFormatDuplicateVolume, volume: volume_name, new_disk: "disks[#{i}]", orig_disk: "disks[#{existing}]"
+              end
+              target_volumes[volume_name] = i
+
+              {
+                :path => image_path,
+                :name => volume_name,
+                :virtual_size => virtual_size,
+                :format => HandleBoxImage.verify_box_format(format)
+              }
+            }
           end
 
           # Get config options
           config = env[:machine].provider_config
-          box_image_file = env[:machine].box.directory.join('box.img').to_s
-          env[:box_volume_name] = env[:machine].box.name.to_s.dup.gsub('/', '-VAGRANTSLASH-')
-          env[:box_volume_name] << "_vagrant_box_image_#{
-          begin
-            env[:machine].box.version.to_s
-          rescue
-            ''
-          end}.img"
+          box_image_files = []
+          env[:box_volumes].each do |d|
+            box_image_files.push(d[:path])
+          end
 
           # Override box_virtual_size
+          box_virtual_size = env[:box_volumes][0][:virtual_size]
           if config.machine_virtual_size
-            if config.machine_virtual_size < box_virtual_size
+            config_machine_virtual_size = ByteNumber.from_GB(config.machine_virtual_size)
+            puts config_machine_virtual_size < box_virtual_size
+            if config_machine_virtual_size < box_virtual_size
               # Warn that a virtual size less than the box metadata size
               # is not supported and will be ignored
               env[:ui].warn I18n.t(
                 'vagrant_libvirt.warnings.ignoring_virtual_size_too_small',
-                  requested: config.machine_virtual_size, minimum: box_virtual_size
+                  requested: config_machine_virtual_size.to_GB, minimum: box_virtual_size.to_GB
               )
             else
               env[:ui].info I18n.t('vagrant_libvirt.manual_resize_required')
-              box_virtual_size = config.machine_virtual_size
+              box_virtual_size = config_machine_virtual_size
             end
           end
           # save for use by later actions
-          env[:box_virtual_size] = box_virtual_size
+          env[:box_volumes][0][:virtual_size] = box_virtual_size
 
           # while inside the synchronize block take care not to call the next
           # action in the chain, as must exit this block first to prevent
           # locking all subsequent actions as well.
           @@lock.synchronize do
-            # Don't continue if image already exists in storage pool.
-            box_volume = env[:machine].provider.driver.connection.volumes.all(
-              name: env[:box_volume_name]
-            ).first
-            break if box_volume && box_volume.id
-
-            # Box is not available as a storage pool volume. Create and upload
-            # it as a copy of local box image.
-            env[:ui].info(I18n.t('vagrant_libvirt.uploading_volume'))
-
-            # Create new volume in storage pool
-            unless File.exist?(box_image_file)
-              raise Vagrant::Errors::BoxNotFound, name: env[:machine].box.name
+            env[:box_volumes].each_index do |i|
+              # Don't continue if image already exists in storage pool.
+              box_volume = env[:machine].provider.driver.connection.volumes.all(
+                name: env[:box_volumes][i][:name]
+              ).first
+              next if box_volume && box_volume.id
+
+              send_box_image(env, config, box_image_files[i], env[:box_volumes][i])
             end
-            box_image_size = File.size(box_image_file) # B
-            message = "Creating volume #{env[:box_volume_name]}"
-            message << " in storage pool #{config.storage_pool_name}."
-            @logger.info(message)
+          end
 
-            @storage_volume_uid = storage_uid env
-            @storage_volume_gid = storage_gid env
+          @app.call(env)
+        end
+
+        protected
 
+        def self.get_volume_name(box, name)
+          vol_name = box.name.to_s.dup.gsub('/', '-VAGRANTSLASH-')
+          vol_name << "_vagrant_box_image_#{
             begin
-              fog_volume = env[:machine].provider.driver.connection.volumes.create(
-                name: env[:box_volume_name],
-                allocation: "#{box_image_size / 1024 / 1024}M",
-                capacity: "#{box_virtual_size}G",
-                format_type: box_format,
-                owner: @storage_volume_uid,
-                group: @storage_volume_gid,
-                pool_name: config.storage_pool_name
-              )
-            rescue Fog::Errors::Error => e
-              raise Errors::FogCreateVolumeError,
-                    error_message: e.message
+              box.version.to_s
+            rescue
+              ''
             end
+          }_#{name.dup.gsub('/', '-SLASH-')}.img"
+        end
 
-            # Upload box image to storage pool
-            ret = upload_image(box_image_file, config.storage_pool_name,
-                               env[:box_volume_name], env) do |progress|
-              rewriting(env[:ui]) do |ui|
-                ui.clear_line
-                ui.report_progress(progress, box_image_size, false)
-              end
-            end
+        def self.get_virtual_size(env)
+          # Virtual size has to be set for allocating space in storage pool.
+          box_virtual_size = env[:machine].box.metadata['virtual_size']
+          raise Errors::NoBoxVirtualSizeSet if box_virtual_size.nil?
+          return ByteNumber.from_GB(box_virtual_size)
+        end
 
-            # Clear the line one last time since the progress meter doesn't
-            # disappear immediately.
-            rewriting(env[:ui]) {|ui| ui.clear_line}
-
-            # If upload failed or was interrupted, remove created volume from
-            # storage pool.
-            if env[:interrupted] || !ret
-              begin
-                fog_volume.destroy
-              rescue
-                nil
-              end
+        def self.get_box_image_path(box, box_name)
+          return box.directory.join(box_name).to_s
+        end
+
+        def self.verify_box_format(box_format, disk_index=nil)
+          if box_format.nil?
+            raise Errors::NoBoxFormatSet
+          elsif box_format != 'qcow2'
+            if disk_index.nil?
+              raise Errors::WrongBoxFormatSet
+            else
+              raise Errors::WrongDiskFormatSet,
+                disk_index: disk_index
             end
           end
+          return box_format
+        end
 
-          @app.call(env)
+        def self.get_box_disk_settings(image_path)
+          stdout, stderr, status = Open3.capture3('qemu-img', 'info', '--output=json', image_path)
+          if !status.success?
+            raise Errors::BadBoxImage, image: image_path, out: stdout, err: stderr
+          end
+
+          image_info = JSON.parse(stdout)
+          format = image_info['format']
+          virtual_size = ByteNumber.new(image_info['virtual-size'])
+
+          return format, virtual_size
         end
 
-        protected
+        def send_box_image(env, config, box_image_file, box_volume)
+          # Box is not available as a storage pool volume. Create and upload
+          # it as a copy of local box image.
+          env[:ui].info(I18n.t('vagrant_libvirt.uploading_volume'))
+
+          # Create new volume in storage pool
+          unless File.exist?(box_image_file)
+            raise Vagrant::Errors::BoxNotFound, name: env[:machine].box.name
+          end
+          box_image_size = File.size(box_image_file) # B
+          message = "Creating volume #{box_volume[:name]}"
+          message << " in storage pool #{config.storage_pool_name}."
+          @logger.info(message)
+          begin
+            fog_volume = env[:machine].provider.driver.connection.volumes.create(
+              name: box_volume[:name],
+              allocation: "#{box_image_size / 1024 / 1024}M",
+              capacity: "#{box_volume[:virtual_size].to_B}B",
+              format_type: box_volume[:format],
+              owner: storage_uid(env),
+              group: storage_gid(env),
+              pool_name: config.storage_pool_name
+            )
+          rescue Fog::Errors::Error => e
+            raise Errors::FogCreateVolumeError,
+                  error_message: e.message
+          end
+
+          # Upload box image to storage pool
+          ret = upload_image(box_image_file, config.storage_pool_name,
+                            box_volume[:name], env) do |progress|
+            rewriting(env[:ui]) do |ui|
+              ui.clear_line
+              ui.report_progress(progress, box_image_size, false)
+            end
+          end
+
+          # Clear the line one last time since the progress meter doesn't
+          # disappear immediately.
+          rewriting(env[:ui]) {|ui| ui.clear_line}
+
+          # If upload failed or was interrupted, remove created volume from
+          # storage pool.
+          if env[:interrupted] || !ret
+            begin
+              fog_volume.destroy
+            rescue
+              nil
+            end
+          end
+        end
 
         # Fog Libvirt currently doesn't support uploading images to storage
         # pool volumes. Use ruby-libvirt client instead.

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

@@ -9,9 +9,7 @@ module VagrantPlugins
         end
 
         def call(env)
-          domain = env[:machine].provider.driver.connection.servers.get(env[:machine].id.to_s)
-          raise Errors::NoDomainError if domain.nil?
-          env[:result] = domain.state.to_s == 'running'
+          env[:result] = env[:machine].state.id == :running
 
           @app.call(env)
         end

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

@@ -16,9 +16,9 @@ module VagrantPlugins
           libvirt_domain = env[:machine].provider.driver.connection.client.lookup_domain_by_uuid(env[:machine].id)
           if config.suspend_mode == 'managedsave'
             if libvirt_domain.has_managed_save?
-              env[:result] = libvirt_domain.has_managed_save?
+              env[:result] = env[:machine].state.id == :shutoff
             else
-              env[:result] = domain.state.to_s == 'paused'
+              env[:result] = env[:machine].state.id == :paused
               if env[:result]
                 env[:ui].warn('One time switching to pause suspend mode, found a paused VM.')
                 config.suspend_mode = 'pause'
@@ -27,10 +27,10 @@ module VagrantPlugins
           else
             if libvirt_domain.has_managed_save?
               env[:ui].warn('One time switching to managedsave suspend mode, state found.')
-              env[:result] = true
+              env[:result] = [:shutoff, :paused].include?(env[:machine].state.id)
               config.suspend_mode = 'managedsave'
             else
-              env[:result] = domain.state.to_s == 'paused'
+              env[:result] = env[:machine].state.id == :paused
             end
           end
 

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

@@ -86,9 +86,13 @@ module VagrantPlugins
 
         def search_network(nets, xml)
           str = '/domain/devices/interface'
-          str += "[(@type='network' or @type='udp' or @type='bridge')"
+          str += "[(@type='network' or @type='udp' or @type='bridge' or @type='direct')"
           unless nets.empty?
-            str += " and source[@network='#{nets.first['network']}']"
+            net = nets.first
+            network = net['network']
+            dev = net['dev']
+            str += " and source[@network='#{network}']" if network
+            str += " and source[@dev='#{dev}']" if dev
           end
           str += ']'
           @logger.debug(str)

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

@@ -47,30 +47,6 @@ module VagrantPlugins
           @logger.info("Got IP address #{env[:ip_address]}")
           @logger.info("Time for getting IP: #{env[:metrics]['instance_ip_time']}")
 
-          # Machine has ip address assigned, now wait till we are able to
-          # connect via ssh.
-          env[:metrics]['instance_ssh_time'] = Util::Timer.time do
-            env[:ui].info(I18n.t('vagrant_libvirt.waiting_for_ssh'))
-            retryable(on: Fog::Errors::TimeoutError, tries: 60) do
-              # If we're interrupted don't worry about waiting
-              next if env[:interrupted]
-
-              # Wait till we are able to connect via ssh.
-              loop do
-                # If we're interrupted then just back out
-                break if env[:interrupted]
-                break if env[:machine].communicate.ready?
-                sleep 2
-              end
-            end
-          end
-          # just return if interrupted and let the warden call recover
-          return if env[:interrupted]
-          @logger.info("Time for SSH ready: #{env[:metrics]['instance_ssh_time']}")
-
-          # Booted and ready for use.
-          # env[:ui].info(I18n.t("vagrant_libvirt.ready"))
-
           @app.call(env)
         end
 
@@ -80,7 +56,7 @@ module VagrantPlugins
         end
 
         def terminate(env)
-          if env[:machine].provider.state.id != :not_created
+          if env[:machine].state.id != :not_created
             # If we're not supposed to destroy on error then just return
             return unless env[:destroy_on_error]
 

data/lib/vagrant-libvirt/cap/{mount_p9.rb → mount_9p.rb}

@@ -4,10 +4,10 @@ require 'vagrant/util/retryable'
 module VagrantPlugins
   module ProviderLibvirt
     module Cap
-      class MountP9
+      class Mount9P
         extend Vagrant::Util::Retryable
 
-        def self.mount_p9_shared_folder(machine, folders)
+        def self.mount_9p_shared_folder(machine, folders)
           folders.each do |_name, opts|
             # Expand the guest path so we can handle things like "~/vagrant"
             expanded_guest_path = machine.guest.capability(