vagrant-qemu 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00ee57a8b6cb0315b36c0084239e92ed69633698845945e6290ba289d71e2889
-  data.tar.gz: 99985f04eabced2eabae1914eacb19f053f13613a4f18d40047ac57440bd4a52
+  metadata.gz: a7af3fcc9e9a9210bea30f44da695c87fbd15c24eed79de64540bb01ec5d4842
+  data.tar.gz: 805730ceb9574de982d6c20f4b8a7e04c37b13fbdc47ca902ddde6fcf844fef5
 SHA512:
-  metadata.gz: ffc285799ee3f7be527da85b03d539c6f1f6b9278bc474c00b63eef41ea937bd8d5bf17aae125d801d3e1a9404967b1df9f0fa2b3173f3db452ed0fc60a12727
-  data.tar.gz: 43601507f85d2bb8e884e24795cdbb64c4d2d03f3842c1a8feb5cefe437241cdc0bcbbc531da4036540b3e19f6aaf831f9b35cad6c91c29c32da42be5f90abb0
+  metadata.gz: d9613c43e9ea63da345bf0745b3825578cb9d32a8e9465b91a9beea36c571e085d9a325675d28e1a98fe655fbabffb0b29f8e6107e90a13dc504ba83e1b007c8
+  data.tar.gz: 96a64e28147f0a7c6c7994695d8b423088f7f3eb80c18288d2652120e24c5479d88d9d407455f10e0ab252a7cacbf0fb2f0c0ef2a22a403c625d3826d5002ec5

data/CHANGELOG.md

@@ -169,3 +169,20 @@
   binary. New config: `socket_vmnet_socket` and `socket_vmnet_client` (default
   to the Homebrew prefix). The static IP must fall within the daemon's subnet
   (`--vmnet-gateway`, default `192.168.105.1/24`); see the README. (#41)
+
+# 0.6.1 (2026-07-22)
+
+* Fix `vagrant reload` (and any other same-process halt-then-start, e.g. the
+  `vagrant-reload` plugin) failing with a QEMU image write-lock error when a
+  custom disk (`config.vm.disk`) was configured. `configure_disks` re-runs on
+  every `action_start`, but the driver's attached-disk list only ever
+  accumulated, so a reload attached each custom disk twice on the same qemu
+  command line. (#41)
+* Fix `qemu-img create` unconditionally recreating an already-existing custom
+  disk on every `configure_disks` call, which silently wiped the disk's
+  contents on every reload (independent of the bug above — resizing an
+  existing disk to a new configured size still isn't supported).
+* Fix the cloud-init network seed ISO (used by `advanced_network` without a
+  core `cloud_init` user-data config, i.e. the `net_mode` examples above)
+  being re-registered as a duplicate disk on every same-process reload,
+  hitting the same QEMU write-lock error via a different disk.

data/lib/vagrant-qemu/action/cloud_init_network.rb

@@ -24,6 +24,10 @@ module VagrantPlugins
         # user-data seed.
         CORE_SEED_DISK_NAME = "vagrant-cloud_init-disk".freeze
 
+        # Disk name this action gives its own network-only seed (no core
+        # user-data seed present).
+        OWN_SEED_DISK_NAME = "vagrant-qemu-network-disk".freeze
+
         def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new("vagrant_qemu::action::cloud_init_network")
@@ -55,13 +59,24 @@ module VagrantPlugins
         private
 
         # No core cloud-init seed: build our own network-only seed and attach
-        # it as a fresh :dvd disk.
+        # it as a fresh :dvd disk. This re-runs on every action_start
+        # (including a same-process reload), so a disk already registered
+        # from an earlier run is rebuilt in place rather than re-registered
+        # -- machine.config.vm.disks has no dedup of its own.
         def attach_network_seed(machine, env, pn)
-          iso_path = build_seed(machine, env, pn,
+          existing = machine.config.vm.disks.find do |d|
+            d.type == :dvd && d.name == OWN_SEED_DISK_NAME
+          end
+
+          iso_path = existing ? Pathname.new(existing.file) : machine.data_dir.join("vagrant-qemu-network.iso")
+
+          build_seed(machine, env, pn,
             user_data: "#cloud-config\n",
-            file_destination: machine.data_dir.join("vagrant-qemu-network.iso"))
+            file_destination: iso_path)
+
+          return if existing
 
-          machine.config.vm.disk :dvd, file: iso_path.to_s, name: "vagrant-qemu-network-disk"
+          machine.config.vm.disk :dvd, file: iso_path.to_s, name: OWN_SEED_DISK_NAME
           machine.config.vm.disks.each do |d|
             d.finalize! if d.type == :dvd && d.file == iso_path.to_s
           end

data/lib/vagrant-qemu/cap/disk.rb

@@ -32,6 +32,11 @@ module VagrantPlugins
         # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
         # @return [Hash] configured_disks - A hash of all the current configured disks
         def self.configure_disks(machine, defined_disks)
+          # Vagrant re-invokes this on every action_start (including a
+          # same-process reload), always passing the complete current disk
+          # list -- reset before the empty check so a disk removed from the
+          # Vagrantfile doesn't leave a stale entry attached either.
+          machine.provider.driver.reset_attached_drives!
           return {} if defined_disks.empty?
 
           configured_disks = {disk: [], floppy: [], dvd: []}
@@ -79,12 +84,17 @@ module VagrantPlugins
         def self.setup_disk(machine, disk)
           disk_dir = machine.provider.driver.disk_dir
           disk_path = disk_dir.join("#{disk.name}.#{disk.disk_ext}")
-          args = ["create", "-f", "qcow2"]
 
           disk_provider_config = disk.provider_config[:qemu] if disk.provider_config
-          args.push(disk_path.to_s)
-          args.push("#{disk.size}")
-          machine.provider.driver.execute("qemu-img", *args)
+
+          # configure_disks re-runs on every action_start (including a
+          # same-process reload); qemu-img create truncates an existing file
+          # unconditionally, so skip it once the disk already exists instead
+          # of silently wiping it. Resizing an existing disk isn't handled.
+          if !disk_path.file?
+            args = ["create", "-f", "qcow2", disk_path.to_s, "#{disk.size}"]
+            machine.provider.driver.execute("qemu-img", *args)
+          end
 
           {UUID: disk.id, Name: disk.name, Path: disk_path.to_s, primary: !!disk.primary}
         end

data/lib/vagrant-qemu/driver.rb

@@ -472,6 +472,14 @@ module VagrantPlugins
         end
       end
 
+      # Vagrant's Disk middleware always passes the *complete* current disk
+      # list and re-runs on every action_start (including a same-process
+      # reload, which reuses this Driver instance) -- so attach_disk/attach_dvd
+      # must be rebuilt from a clean slate each time, not accumulated across calls.
+      def reset_attached_drives!
+        @attached_drives = {disk: [], floppy: [], dvd: []}
+      end
+
       def attach_dvd(disk)
         @attached_drives[:dvd] << disk
       end

data/lib/vagrant-qemu/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module QEMU
-    VERSION = '0.6.0'
+    VERSION = '0.6.1'
   end
 end

data/spec/e2e/disk_spec.rb

@@ -32,4 +32,76 @@ describe "extra disk attachment end-to-end", :requires_qemu do
     expect(ssh[:exit_code]).to eq 0
     expect(ssh[:stdout].lines.last.to_s.strip.to_i).to be >= 2
   end
+
+  it "reload with an extra disk does not hit a QEMU image-lock error" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.disk :disk, name: "extra", size: "1GB"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+        end
+      end
+    RUBY
+
+    result = vagrant_up(@work_dir, timeout: 600)
+    expect(result[:exit_code]).to eq 0
+
+    # This is the exact same-process halt->start path a same-process reload
+    # takes (issue #41: reload used to re-attach the extra disk a second
+    # time, so QEMU refused its own duplicate -drive with a write-lock error).
+    reload = vagrant_reload(@work_dir, timeout: 600)
+    expect(reload[:exit_code]).to eq 0
+    expect(reload[:stderr]).not_to match(/Failed to get "write" lock/)
+
+    ssh = vagrant_ssh(@work_dir, command: %q{lsblk -d -n -o TYPE | grep -c '^disk$'})
+    expect(ssh[:exit_code]).to eq 0
+    expect(ssh[:stdout].lines.last.to_s.strip.to_i).to be >= 2
+  end
+
+  it "reload does not wipe data already written to an extra disk" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.disk :disk, name: "extra", size: "1GB"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+        end
+      end
+    RUBY
+
+    result = vagrant_up(@work_dir, timeout: 600)
+    expect(result[:exit_code]).to eq 0
+
+    setup = vagrant_ssh(@work_dir, command: <<~SH)
+      set -e
+      dev=$(lsblk -d -n -o NAME,TYPE | awk '$2=="disk"{print $1}' | grep -v vda | head -1)
+      sudo mkfs.ext4 -F /dev/$dev
+      sudo mkdir -p /mnt/extra
+      sudo mount /dev/$dev /mnt/extra
+      echo marker-should-survive-reload | sudo tee /mnt/extra/marker.txt
+      sudo umount /mnt/extra
+    SH
+    expect(setup[:exit_code]).to eq 0
+
+    # configure_disks unconditionally ran `qemu-img create` on every
+    # action_start (including this same-process reload), silently
+    # truncating the extra disk every time -- this is the regression test.
+    reload = vagrant_reload(@work_dir, timeout: 600)
+    expect(reload[:exit_code]).to eq 0
+
+    check = vagrant_ssh(@work_dir, command: <<~SH)
+      set -e
+      dev=$(lsblk -d -n -o NAME,TYPE | awk '$2=="disk"{print $1}' | grep -v vda | head -1)
+      sudo mkdir -p /mnt/extra
+      sudo mount /dev/$dev /mnt/extra
+      cat /mnt/extra/marker.txt
+    SH
+    expect(check[:exit_code]).to eq 0
+    expect(check[:stdout]).to include("marker-should-survive-reload")
+  end
 end

data/spec/spec_helper.rb

@@ -20,6 +20,7 @@ require "vagrant-qemu/action/start_instance"
 require "vagrant-qemu/action/read_state"
 require "vagrant-qemu/action/stop_instance"
 require "vagrant-qemu/action/prepare_forwarded_port_collision_params"
+require "vagrant-qemu/cap/disk"
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|

data/spec/unit/action/cloud_init_network_spec.rb

@@ -33,8 +33,15 @@ describe VagrantPlugins::QEMU::Action::CloudInitNetwork do
 
     allow(vm_config).to receive(:networks).and_return(networks)
     allow(vm_config).to receive(:cloud_init_configs).and_return([])
-    allow(vm_config).to receive(:disk)
-    allow(vm_config).to receive(:disks).and_return([])
+
+    # Stateful, unlike a plain double: .disk actually appends, so a test can
+    # call the action twice (simulating a same-process reload re-running
+    # action_start) and observe whether registration is idempotent.
+    @disks_registered = []
+    allow(vm_config).to receive(:disks) { @disks_registered }
+    allow(vm_config).to receive(:disk) do |type, **opts|
+      @disks_registered << double("disk_config", type: type, name: opts[:name], file: opts[:file], finalize!: nil)
+    end
 
     allow(host).to receive(:capability?).with(:create_iso).and_return(true)
 
@@ -129,6 +136,14 @@ describe VagrantPlugins::QEMU::Action::CloudInitNetwork do
     end
   end
 
+  it "does not register a second seed disk on a repeated call (same-process reload)" do
+    run_action
+    expect(vm_config.disks.length).to eq(1)
+
+    run_action
+    expect(vm_config.disks.length).to eq(1)
+  end
+
   it "raises when the host cannot build ISOs" do
     allow(host).to receive(:capability?).with(:create_iso).and_return(false)
     expect { run_action }.to raise_error(Vagrant::Errors::CreateIsoHostCapNotFound)

data/spec/unit/cap/disk_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+describe VagrantPlugins::QEMU::Cap::Disk, ".configure_disks" do
+  let(:vm_id) { "vq_testid123" }
+
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @data_dir = dir.join("data")
+      @tmp_base = dir.join("tmp")
+      FileUtils.mkdir_p(@data_dir)
+      FileUtils.mkdir_p(@tmp_base)
+      FileUtils.mkdir_p(@data_dir.join(vm_id))
+      example.run
+    end
+  end
+
+  # A real Driver (not a double) -- attached_drives accumulation is the exact
+  # mechanism under test, so it must be the production object.
+  let(:driver) { VagrantPlugins::QEMU::Driver.new(vm_id, @data_dir, @tmp_base) }
+
+  let(:machine) do
+    provider = double("provider", driver: driver)
+    double("machine", provider: provider)
+  end
+
+  let(:disk) do
+    double("disk",
+      type: :disk, name: "disk1", disk_ext: "qcow2", size: "10G",
+      id: "disk1-uuid", primary: false, provider_config: nil)
+  end
+
+  before do
+    # Avoid actually shelling out to qemu-img.
+    allow(driver).to receive(:execute)
+  end
+
+  it "reflects one entry per disk after a single configure_disks call" do
+    described_class.configure_disks(machine, [disk])
+
+    expect(driver.attached_drives[:disk].length).to eq(1)
+  end
+
+  it "does not duplicate a disk across a second configure_disks call on the same driver (reload)" do
+    described_class.configure_disks(machine, [disk])
+    # action_start (and its Disk middleware) re-runs on the same Driver
+    # instance during a same-process reload (action_halt -> action_start).
+    described_class.configure_disks(machine, [disk])
+
+    expect(driver.attached_drives[:disk].length).to eq(1)
+  end
+
+  it "does not accumulate across repeated reloads" do
+    3.times { described_class.configure_disks(machine, [disk]) }
+
+    expect(driver.attached_drives[:disk].length).to eq(1)
+  end
+
+  it "clears a stale disk once it is removed from the Vagrantfile" do
+    described_class.configure_disks(machine, [disk])
+    expect(driver.attached_drives[:disk].length).to eq(1)
+
+    described_class.configure_disks(machine, [])
+
+    expect(driver.attached_drives[:disk]).to be_empty
+  end
+
+  describe "disk file idempotency (reload must not wipe existing disk data)" do
+    let(:disk_path) { @data_dir.join(vm_id).join("disk1.qcow2") }
+
+    it "does not recreate the qcow2 file when it already exists" do
+      FileUtils.touch(disk_path)
+
+      expect(driver).not_to receive(:execute)
+        .with("qemu-img", "create", "-f", "qcow2", disk_path.to_s, "10G")
+
+      described_class.configure_disks(machine, [disk])
+    end
+
+    it "does not recreate on a second configure_disks call (reload)" do
+      # Simulate the real qemu-img side effect (the outer stub is a no-op),
+      # so the second call's existence check reflects what actually happens.
+      allow(driver).to receive(:execute) do |*args|
+        FileUtils.touch(disk_path) if args[0, 2] == ["qemu-img", "create"]
+      end
+
+      described_class.configure_disks(machine, [disk])
+      expect(File.exist?(disk_path)).to be true
+
+      expect(driver).not_to receive(:execute)
+        .with("qemu-img", "create", "-f", "qcow2", disk_path.to_s, "10G")
+
+      described_class.configure_disks(machine, [disk])
+    end
+
+    it "creates the qcow2 file when it does not exist yet" do
+      expect(File.exist?(disk_path)).to be false
+
+      expect(driver).to receive(:execute)
+        .with("qemu-img", "create", "-f", "qcow2", disk_path.to_s, "10G")
+
+      described_class.configure_disks(machine, [disk])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-qemu
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - ppggff
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-21 00:00:00.000000000 Z
+date: 2026-07-22 00:00:00.000000000 Z
 dependencies: []
 description: Enables Vagrant to manage machines with QEMU.
 email: pgf00a@gmail.com
@@ -83,6 +83,7 @@ files:
 - spec/unit/action/start_instance_port_spec.rb
 - spec/unit/action/start_instance_spec.rb
 - spec/unit/action/warn_networks_spec.rb
+- spec/unit/cap/disk_spec.rb
 - spec/unit/config_spec.rb
 - spec/unit/driver/delete_spec.rb
 - spec/unit/driver/options_yaml_spec.rb