vagrant-libvirt 0.4.1 → 0.5.0

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

@@ -18,72 +18,74 @@ module VagrantPlugins
         def call(env)
           env[:ui].info(I18n.t('vagrant_libvirt.creating_domain_volume'))
 
-          # Get config options.
-          config = env[:machine].provider_config
+          env[:box_volumes].each_index do |index|
+            suffix_index = index > 0 ? "_#{index}" : ''
+            # Get config options.
+            config = env[:machine].provider_config
 
-          # This is name of newly created image for vm.
-          @name = "#{env[:domain_name]}.img"
+            # This is name of newly created image for vm.
+            @name = "#{env[:domain_name]}#{suffix_index}.img"
 
-          # Verify the volume doesn't exist already.
-          domain_volume = env[:machine].provider.driver.connection.volumes.all(
-            name: @name
-          ).first
-          raise Errors::DomainVolumeExists if domain_volume && domain_volume.id
+            # Verify the volume doesn't exist already.
+            domain_volume = env[:machine].provider.driver.connection.volumes.all(
+              name: @name
+            ).first
+            raise Errors::DomainVolumeExists if domain_volume && domain_volume.id
 
-          # Get path to backing image - box volume.
-          box_volume = env[:machine].provider.driver.connection.volumes.all(
-            name: env[:box_volume_name]
-          ).first
-          @backing_file = box_volume.path
+            # Get path to backing image - box volume.
+            box_volume = env[:machine].provider.driver.connection.volumes.all(
+              name: env[:box_volumes][index][:name]
+            ).first
+            @backing_file = box_volume.path
 
-          # Virtual size of image. Take value worked out by HandleBoxImage
-          @capacity = env[:box_virtual_size] # G
+            # Virtual size of image. Take value worked out by HandleBoxImage
+            @capacity = env[:box_volumes][index][:virtual_size] # G
 
-          # Create new volume from xml template. Fog currently doesn't support
-          # volume snapshots directly.
-          begin
-            xml = Nokogiri::XML::Builder.new do |xml|
-              xml.volume do
-                xml.name(@name)
-                xml.capacity(@capacity, unit: 'G')
-                xml.target do
-                  xml.format(type: 'qcow2')
-                  xml.permissions do
-                    xml.owner storage_uid(env)
-                    xml.group storage_gid(env)
-                    xml.label 'virt_image_t'
+            # Create new volume from xml template. Fog currently doesn't support
+            # volume snapshots directly.
+            begin
+              xml = Nokogiri::XML::Builder.new do |xml|
+                xml.volume do
+                  xml.name(@name)
+                  xml.capacity(@capacity, unit: 'G')
+                  xml.target do
+                    xml.format(type: 'qcow2')
+                    xml.permissions do
+                      xml.owner storage_uid(env)
+                      xml.group storage_gid(env)
+                      xml.label 'virt_image_t'
+                    end
                   end
-                end
-                xml.backingStore do
-                  xml.path(@backing_file)
-                  xml.format(type: 'qcow2')
-                  xml.permissions do
-                    xml.owner storage_uid(env)
-                    xml.group storage_gid(env)
-                    xml.label 'virt_image_t'
+                  xml.backingStore do
+                    xml.path(@backing_file)
+                    xml.format(type: 'qcow2')
+                    xml.permissions do
+                      xml.owner storage_uid(env)
+                      xml.group storage_gid(env)
+                      xml.label 'virt_image_t'
+                    end
                   end
                 end
+              end.to_xml(
+                save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION |
+                          Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
+                          Nokogiri::XML::Node::SaveOptions::FORMAT
+              )
+              if config.snapshot_pool_name != config.storage_pool_name
+                  pool_name = config.snapshot_pool_name
+              else
+                  pool_name = config.storage_pool_name
               end
-            end.to_xml(
-              save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION |
-                         Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
-                         Nokogiri::XML::Node::SaveOptions::FORMAT
-            )
-            if config.snapshot_pool_name != config.storage_pool_name
-                pool_name = config.snapshot_pool_name
-            else
-                pool_name = config.storage_pool_name
+              @logger.debug "Using pool #{pool_name} for base box snapshot"
+              domain_volume = env[:machine].provider.driver.connection.volumes.create(
+                xml: xml,
+                pool_name: pool_name
+              )
+            rescue Fog::Errors::Error => e
+              raise Errors::FogDomainVolumeCreateError,
+                    error_message: e.message
             end
-            @logger.debug "Using pool #{pool_name} for base box snapshot"
-            domain_volume = env[:machine].provider.driver.connection.volumes.create(
-              xml: xml,
-              pool_name: pool_name
-            )
-          rescue Fog::Errors::Error => e
-            raise Errors::FogDomainVolumeCreateError,
-                  error_message: e.message
           end
-
           @app.call(env)
         end
       end

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

@@ -214,9 +214,6 @@ module VagrantPlugins
                 network[:type] = :dhcp
               end
 
-              # do not run configure_networks for tcp tunnel interfaces
-              next if options.fetch(:tunnel_type, nil)
-
               networks_to_configure << network
             end
 

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

@@ -54,6 +54,8 @@ module VagrantPlugins
                 env[:machine].provider.driver.connection.client
               )
 
+              current_network = @available_networks.detect { |network| network[:name] == @options[:network_name] }
+
               # Prepare a hash describing network for this specific interface.
               @interface_network = {
                 name:             nil,
@@ -64,11 +66,11 @@ module VagrantPlugins
                 domain_name:      nil,
                 ipv6_address:     options[:ipv6_address] || nil,
                 ipv6_prefix:      options[:ipv6_prefix] || nil,
-                created:          false,
-                active:           false,
+                created:          current_network.nil? ? false : true,
+                active:           current_network.nil? ? false : current_network[:active],
                 autostart:        options[:autostart] || false,
                 guest_ipv6:       @options[:guest_ipv6] || 'yes',
-                libvirt_network:  nil
+                libvirt_network:  current_network.nil? ? nil : current_network[:libvirt_network]
               }
 
               if @options[:ip]
@@ -255,7 +257,9 @@ module VagrantPlugins
 
           # Do we need to create new network?
           unless @interface_network[:created]
-            @interface_network[:name] = 'vagrant-private-dhcp'
+            @interface_network[:name] = @options[:network_name] ?
+                                        @options[:network_name] :
+                                        'vagrant-private-dhcp'
             @interface_network[:network_address] = net_address
 
             # Set IP address of network (actually bridge). It will be used as
@@ -297,6 +301,9 @@ module VagrantPlugins
 
           @network_ipv6_address = @interface_network[:ipv6_address]
           @network_ipv6_prefix = @interface_network[:ipv6_prefix]
+          
+          @network_bridge_stp = @options[:bridge_stp].nil? || @options[:bridge_stp] ? 'on' : 'off'
+          @network_bridge_delay = @options[:bridge_delay] ? @options[:bridge_delay] : 0
 
           @network_forward_mode = @options[:forward_mode]
           if @options[:forward_device]

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

@@ -70,7 +70,7 @@ module VagrantPlugins
 
             # remove root storage
             root_disk = domain.volumes.select do |x|
-              x.name == libvirt_domain.name + '.img'
+              x.name == libvirt_domain.name + '.img' if x
             end.first
             root_disk.destroy if root_disk
           end

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

@@ -11,10 +11,8 @@ module VagrantPlugins
         end
 
         def call(env)
-          @env = env
-
           # Get the ports we're forwarding
-          env[:forwarded_ports] = compile_forwarded_ports(env[:machine].config)
+          env[:forwarded_ports] = compile_forwarded_ports(env, env[:machine].config)
 
           # Warn if we're port forwarding to any privileged ports
           env[:forwarded_ports].each do |fp|
@@ -28,51 +26,52 @@ module VagrantPlugins
           # Continue, we need the VM to be booted in order to grab its IP
           @app.call env
 
-          if @env[:forwarded_ports].any?
+          if env[:forwarded_ports].any?
             env[:ui].info I18n.t('vagrant.actions.vm.forward_ports.forwarding')
-            forward_ports
+            forward_ports(env)
           end
         end
 
-        def forward_ports
-          @env[:forwarded_ports].each do |fp|
+        def forward_ports(env)
+          env[:forwarded_ports].each do |fp|
             message_attributes = {
               adapter: fp[:adapter] || 'eth0',
               guest_port: fp[:guest],
               host_port: fp[:host]
             }
 
-            @env[:ui].info(I18n.t(
+            env[:ui].info(I18n.t(
                              'vagrant.actions.vm.forward_ports.forwarding_entry',
-                             message_attributes
+                             **message_attributes
             ))
 
-            if fp[:protocol] == 'udp'
-              @env[:ui].warn I18n.t('vagrant_libvirt.warnings.forwarding_udp')
-              next
-            end
-
             ssh_pid = redirect_port(
-              @env[:machine],
+              env,
+              env[:machine],
               fp[:host_ip] || '*',
               fp[:host],
-              fp[:guest_ip] || @env[:machine].provider.ssh_info[:host],
+              fp[:guest_ip] || env[:machine].provider.ssh_info[:host],
               fp[:guest],
               fp[:gateway_ports] || false
             )
-            store_ssh_pid(fp[:host], ssh_pid)
+            store_ssh_pid(env[:machine], fp[:host], ssh_pid)
           end
         end
 
         private
 
-        def compile_forwarded_ports(config)
+        def compile_forwarded_ports(env, config)
           mappings = {}
 
           config.vm.networks.each do |type, options|
             next if options[:disabled]
 
-            next unless type == :forwarded_port && options[:id] != 'ssh'
+            if options[:protocol] == 'udp'
+              env[:ui].warn I18n.t('vagrant_libvirt.warnings.forwarding_udp')
+              next
+            end
+
+            next if type != :forwarded_port || ( options[:id] == 'ssh' && !env[:machine].provider_config.forward_ssh_port )
             if options.fetch(:host_ip, '').to_s.strip.empty?
               options.delete(:host_ip)
             end
@@ -82,7 +81,7 @@ module VagrantPlugins
           mappings.values
         end
 
-        def redirect_port(machine, host_ip, host_port, guest_ip, guest_port,
+        def redirect_port(env, machine, host_ip, host_port, guest_ip, guest_port,
                           gateway_ports)
           ssh_info = machine.ssh_info
           params = %W(
@@ -114,7 +113,7 @@ module VagrantPlugins
           if host_port <= 1024
             @@lock.synchronize do
               # TODO: add i18n
-              @env[:ui].info 'Requesting sudo for host port(s) <= 1024'
+              env[:ui].info 'Requesting sudo for host port(s) <= 1024'
               r = system('sudo -v')
               if r
                 ssh_cmd << 'sudo ' # add sudo prefix
@@ -125,14 +124,15 @@ module VagrantPlugins
           ssh_cmd << "ssh -n #{options} #{params}"
 
           @logger.debug "Forwarding port with `#{ssh_cmd}`"
-          log_file = ssh_forward_log_file(host_ip, host_port,
-                                          guest_ip, guest_port)
+          log_file = ssh_forward_log_file(
+            env[:machine], host_ip, host_port, guest_ip, guest_port,
+          )
           @logger.info "Logging to #{log_file}"
           spawn(ssh_cmd, [:out, :err] => [log_file, 'w'], :pgroup => true)
         end
 
-        def ssh_forward_log_file(host_ip, host_port, guest_ip, guest_port)
-          log_dir = @env[:machine].data_dir.join('logs')
+        def ssh_forward_log_file(machine, host_ip, host_port, guest_ip, guest_port)
+          log_dir = machine.data_dir.join('logs')
           log_dir.mkdir unless log_dir.directory?
           File.join(
             log_dir,
@@ -141,8 +141,8 @@ module VagrantPlugins
           )
         end
 
-        def store_ssh_pid(host_port, ssh_pid)
-          data_dir = @env[:machine].data_dir.join('pids')
+        def store_ssh_pid(machine, host_port, ssh_pid)
+          data_dir = machine.data_dir.join('pids')
           data_dir.mkdir unless data_dir.directory?
 
           data_dir.join("ssh_#{host_port}.pid").open('w') do |pid_file|
@@ -169,13 +169,12 @@ module VagrantPlugins
         end
 
         def call(env)
-          @env = env
-
-          if ssh_pids.any?
+          pids = ssh_pids(env[:machine])
+          if pids.any?
             env[:ui].info I18n.t(
               'vagrant.actions.vm.clear_forward_ports.deleting'
             )
-            ssh_pids.each do |tag|
+            pids.each do |tag|
               next unless ssh_pid?(tag[:pid])
               @logger.debug "Killing pid #{tag[:pid]}"
               kill_cmd = ''
@@ -191,7 +190,7 @@ module VagrantPlugins
             end
 
             @logger.info 'Removing ssh pid files'
-            remove_ssh_pids
+            remove_ssh_pids(env[:machine])
           else
             @logger.info 'No ssh pids found'
           end
@@ -201,9 +200,9 @@ module VagrantPlugins
 
         protected
 
-        def ssh_pids
-          glob = @env[:machine].data_dir.join('pids').to_s + '/ssh_*.pid'
-          @ssh_pids = Dir[glob].map do |file|
+        def ssh_pids(machine)
+          glob = machine.data_dir.join('pids').to_s + '/ssh_*.pid'
+          ssh_pids = Dir[glob].map do |file|
             {
               pid: File.read(file).strip.chomp,
               port: File.basename(file)['ssh_'.length..-1 * ('.pid'.length + 1)].to_i
@@ -217,8 +216,8 @@ module VagrantPlugins
           `ps -o command= #{pid}`.strip.chomp =~ /ssh/
         end
 
-        def remove_ssh_pids
-          glob = @env[:machine].data_dir.join('pids').to_s + '/ssh_*.pid'
+        def remove_ssh_pids(machine)
+          glob = machine.data_dir.join('pids').to_s + '/ssh_*.pid'
           Dir[glob].each do |file|
             File.delete file
           end

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

@@ -16,33 +16,69 @@ 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.to_i,
+                :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
               # Warn that a virtual size less than the box metadata size
@@ -57,77 +93,129 @@ module VagrantPlugins
             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
+
+          @app.call(env)
+        end
 
-            @storage_volume_uid = storage_uid env
-            @storage_volume_gid = storage_gid env
+        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 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', image_path)
+          if !status.success?
+            raise Errors::BadBoxImage, image: image_path, out: stdout, err: stderr
+          end
+
+          image_info_lines = stdout.split("\n")
+          format = image_info_lines.find { |l| l.start_with?('file format:') }.split(' ')[2]
+          virtual_size = image_info_lines.find { |l| l.start_with?('virtual size:') }.split(' ')[2]
+
+          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]}G",
+              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.