vagrant-qemu 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35de3b54145ee419e9cada4bd6b879fa0e9f7faef93e27da8e750346dcd6c0b7
-  data.tar.gz: 8e0069a3cce24d59ab4723108bd54199cb6019a8a47c587601795bd6a9cc91a1
+  metadata.gz: 4cd40c0eae22a6a6d4f284004a86de09e0584e8887cc273e9acd4c0fa2f33e69
+  data.tar.gz: 4caaa2706bbb8f221dcc67e5164e7b38879e3cb2d709d8414fc1f0a0ed0de45b
 SHA512:
-  metadata.gz: de578f059ba6ee08339738a906e366f8b8f33acc7b6389b05d68af4d365ceb6829e6d2ac7cf84214d7ff5f7af8510d657228ebd08fa0f444d40a962e23001cae
-  data.tar.gz: 5f74816cd5c18bf5ad492e546fea36d972b32585ebb0f360f1bd6cf2bbe70e475ea69365f6ff228addb5d8179feaa7944d74bfd80f4982dbd80eb7d2c7605a1b
+  metadata.gz: dd592ca7bf0a75c82b58db4ed8194f8a3e31b44834538ea0fe7ae7124032871422b9b4f2f6b49122964fefc0692f02d1be4a018bae2e4948f3f8aeeb9385eaaf
+  data.tar.gz: 906b02b551b9f3c5082a3967edc33c656f9b642ae0f6bbabcd8bb40b944fa0e2d67f10c5b6b34af3291516c218d0d7657c47d9cf495d1dabceb63fa5acb4ac77

data/CHANGELOG.md

@@ -101,6 +101,14 @@
 * Add support for cloud-init and disks
 * Add support for resizing disk on vm setup
 
+# 0.4.1 (2026-06-22)
+
+* `vagrant halt` now reaps QEMU even when the guest was already halted from
+  inside (e.g. `sudo systemctl halt`), where the ACPI `system_powerdown` is a
+  no-op. Halt escalates: `system_powerdown` -> wait `graceful_timeout` -> QEMU
+  `quit` monitor command (clean: flushes and closes the disk images) -> wait
+  `graceful_timeout` -> SIGKILL as a last resort (#79)
+
 # 0.4.0 (2026-06-12)
 
 * Advanced networking (opt-in, `advanced_network = true`): dual-NIC `private_network`

data/README.md

@@ -105,7 +105,7 @@ This provider exposes a few provider-specific configuration options:
   * `firmware_format` - The format of aarch64 firmware images (`edk2-aarch64-code.fd` and `edk2-arm-vars.fd`) loaded from `qemu_dir`, default: `raw`
   * `other_default` - The other default arguments used by this plugin, default: `%W(-parallel null -monitor none -display none -vga none)`
   * `extra_image_opts` - Options passed via `-o` to `qemu-img` when the base qcow2 images are created, default: `[]`
-  * `graceful_timeout` - Seconds to wait for the guest to shut down on `vagrant halt` before the QEMU process is force-killed, default: `60`
+  * `graceful_timeout` - Seconds to wait at each `vagrant halt` stage before escalating, default: `60`. Halt sends ACPI `system_powerdown`, waits up to this long, then sends QEMU's `quit` monitor command (a clean shutdown that flushes and closes the disk images), waits again, and finally SIGKILLs QEMU as a last resort — so halt still completes even when the guest was already halted from inside (e.g. `sudo systemctl halt`), where `system_powerdown` is a no-op
 * advanced networking (requires `advanced_network = true`)
   * `advanced_network` - Enable dual-NIC advanced networking with `private_network` support, default: `false`
   * `net_mode` - Network backend: `:auto` (detect by platform), `:vmnet_shared`, `:vmnet_host`, `:vmnet_bridged` (macOS), `:tap` (Linux), `:socket` (QEMU `socket` netdev — multicast or point-to-point, see `socket_opts`), default: `:auto`

data/lib/vagrant-qemu/driver.rb

@@ -212,10 +212,27 @@ module VagrantPlugins
       end
 
       def stop(options)
-        if running?
-          send_powerdown(with_persisted_control_port(options))
-          wait_for_shutdown(options[:graceful_timeout] || 60)
-        end
+        return unless running?
+
+        opts = with_persisted_control_port(options)
+        timeout = options[:graceful_timeout] || 60
+
+        # 1. ACPI power button (graceful). Only works if a live guest OS is
+        #    there to act on it -- e.g. NOT after `systemctl halt`, which leaves
+        #    QEMU running with a halted, unresponsive guest.
+        send_monitor(opts, "system_powerdown")
+        return unless still_running_after?(timeout)
+
+        # 2. Powerdown didn't take. Ask QEMU itself to quit: it stops the VM,
+        #    flushes and closes the qcow2 images, then exits cleanly. Does not
+        #    depend on the guest, only on the monitor being reachable.
+        @logger.warn("VM did not power down within #{timeout}s; sending 'quit' to QEMU")
+        send_monitor(opts, "quit")
+        return unless still_running_after?(timeout)
+
+        # 3. Last resort: SIGKILL the QEMU process (no flush/cleanup).
+        @logger.warn("VM still running after 'quit'; forcing kill")
+        force_kill
       end
 
       private
@@ -232,35 +249,37 @@ module VagrantPlugins
         options.merge(:control_port => persisted[:control_port])
       end
 
-      def send_powerdown(options)
+      # Send a single QEMU monitor command over the control channel (TCP
+      # control_port if set, else the unix monitor socket). Best-effort: the
+      # socket may already be gone (e.g. QEMU exited from a prior command), so
+      # connection errors are swallowed.
+      def send_monitor(options, command)
         if !options[:control_port].nil?
           Socket.tcp("localhost", options[:control_port], connect_timeout: 5) do |sock|
-            sock.print "system_powerdown\n"
+            sock.print "#{command}\n"
             sock.close_write
             sock.read rescue nil
           end
         else
-          id_tmp_dir = @tmp_dir.join(@vm_id)
-          unix_socket_path = id_tmp_dir.join("qemu_socket").to_s
+          unix_socket_path = @tmp_dir.join(@vm_id).join("qemu_socket").to_s
           Socket.unix(unix_socket_path) do |sock|
-            sock.print "system_powerdown\n"
+            sock.print "#{command}\n"
             sock.close_write
             sock.read rescue nil
           end
         end
+      rescue => e
+        @logger.debug("monitor command '#{command}' failed: #{e}") if @logger
       end
 
-      def wait_for_shutdown(timeout)
+      # Poll for up to `timeout` seconds. Return false as soon as the VM has
+      # stopped; return true if it is still running when the timeout elapses.
+      def still_running_after?(timeout)
         timeout.times do
-          return unless running?
+          return false unless running?
           sleep 1
         end
-
-        # Still running after timeout, force kill
-        if running?
-          @logger.warn("VM did not shut down within #{timeout}s, forcing kill")
-          force_kill
-        end
+        running?
       end
 
       def force_kill

data/lib/vagrant-qemu/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module QEMU
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

data/spec/e2e/halt_spec.rb

@@ -0,0 +1,48 @@
+require_relative "helper"
+
+# Regression for #79: `vagrant halt` must actually reap QEMU even when the
+# guest OS was already halted from inside (e.g. `sudo systemctl halt`). In that
+# state the ACPI `system_powerdown` is a no-op (no live guest to act on it), so
+# halt has to escalate to QEMU's `quit` monitor command and, failing that, to
+# SIGKILL. A short graceful_timeout keeps the escalation fast.
+describe "halt reaps QEMU when the guest is already halted (#79)", :requires_qemu do
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @work_dir = dir.join("project")
+      FileUtils.mkdir_p(@work_dir)
+
+      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.provider "qemu" do |qe|
+            qe.memory = "2G"
+            qe.graceful_timeout = 5
+          end
+        end
+      RUBY
+
+      example.run
+
+      vagrant_destroy(@work_dir) rescue nil
+    end
+  end
+
+  it "stops the VM after the guest was halted from inside" do
+    vagrant_up(@work_dir)
+
+    # Halt the guest OS from inside; the SSH connection drops as it goes down,
+    # so ignore the result. After this, system_powerdown can no longer work.
+    vagrant_ssh(@work_dir, command: "sudo systemctl halt", timeout: 30) rescue nil
+    sleep 3
+
+    # Without the escalation, QEMU would linger and the VM would still report
+    # running; with it, halt reaps the process within ~graceful_timeout.
+    result = vagrant_halt(@work_dir, timeout: 60)
+    expect(result[:exit_code]).to eq 0
+
+    status = vagrant_status(@work_dir)
+    expect(status[:stdout]).to include(",state,stopped")
+  end
+end

data/spec/unit/driver/stop_spec.rb

@@ -16,47 +16,55 @@ describe VagrantPlugins::QEMU::Driver, "#stop" do
   subject { described_class.new(vm_id, @data_dir, @tmp_base) }
 
   it "does nothing when not running" do
-    expect(subject).not_to receive(:send_powerdown)
+    allow(subject).to receive(:running?).and_return(false)
+    expect(subject).not_to receive(:send_monitor)
     subject.stop(control_port: nil)
   end
 
-  it "sends powerdown when running" do
+  it "sends system_powerdown first and stops there when the guest powers off" do
+    # running on the initial check, stopped on the first poll
     allow(subject).to receive(:running?).and_return(true, false)
-    allow(subject).to receive(:send_powerdown)
+    allow(subject).to receive(:send_monitor)
 
-    subject.stop(control_port: nil)
+    subject.stop(control_port: nil, graceful_timeout: 5)
 
-    expect(subject).to have_received(:send_powerdown)
+    expect(subject).to have_received(:send_monitor).with(anything, "system_powerdown")
+    expect(subject).not_to have_received(:send_monitor).with(anything, "quit")
   end
 
-  it "returns when VM shuts down within timeout" do
-    call_count = 0
-    allow(subject).to receive(:running?) do
-      call_count += 1
-      call_count <= 1 # running on first call, stopped on second
-    end
-    allow(subject).to receive(:send_powerdown)
+  it "escalates to 'quit' when powerdown does not stop the VM" do
+    allow(subject).to receive(:sleep)
+    # stays up through the powerdown wait, then stops during the quit wait
+    allow(subject).to receive(:running?).and_return(true, true, true, false)
+    allow(subject).to receive(:send_monitor)
+    expect(subject).not_to receive(:force_kill)
 
-    subject.stop(control_port: nil, graceful_timeout: 5)
+    subject.stop(control_port: nil, graceful_timeout: 1)
+
+    expect(subject).to have_received(:send_monitor).with(anything, "system_powerdown").ordered
+    expect(subject).to have_received(:send_monitor).with(anything, "quit").ordered
   end
 
-  it "force kills when VM does not shut down within timeout" do
-    allow(subject).to receive(:running?).and_return(true)
-    allow(subject).to receive(:send_powerdown)
+  it "force kills only after both powerdown and 'quit' fail" do
     allow(subject).to receive(:sleep)
+    allow(subject).to receive(:running?).and_return(true) # never stops
+    allow(subject).to receive(:send_monitor)
 
     pid_dir = @tmp_base.join("vagrant-qemu", vm_id)
     FileUtils.mkdir_p(pid_dir)
     File.write(pid_dir.join("qemu.pid"), "999999999")
-
     allow(Process).to receive(:kill).with("KILL", 999999999).and_raise(Errno::ESRCH)
 
-    expect { subject.stop(control_port: nil, graceful_timeout: 1) }.not_to raise_error
+    subject.stop(control_port: nil, graceful_timeout: 1)
+
+    expect(subject).to have_received(:send_monitor).with(anything, "system_powerdown")
+    expect(subject).to have_received(:send_monitor).with(anything, "quit")
+    expect(Process).to have_received(:kill).with("KILL", 999999999)
   end
 
   it "prefers the persisted control_port over the configured one" do
     allow(subject).to receive(:running?).and_return(true, false)
-    allow(subject).to receive(:send_powerdown)
+    allow(subject).to receive(:send_monitor)
 
     opts_dir = @tmp_base.join("vagrant-qemu", vm_id)
     FileUtils.mkdir_p(opts_dir)
@@ -64,29 +72,28 @@ describe VagrantPlugins::QEMU::Driver, "#stop" do
 
     subject.stop(control_port: 33333)
 
-    expect(subject).to have_received(:send_powerdown)
-      .with(hash_including(control_port: 44444))
+    expect(subject).to have_received(:send_monitor)
+      .with(hash_including(control_port: 44444), "system_powerdown")
   end
 
   it "keeps the configured control_port when nothing is persisted" do
     allow(subject).to receive(:running?).and_return(true, false)
-    allow(subject).to receive(:send_powerdown)
+    allow(subject).to receive(:send_monitor)
 
     subject.stop(control_port: 33333)
 
-    expect(subject).to have_received(:send_powerdown)
-      .with(hash_including(control_port: 33333))
+    expect(subject).to have_received(:send_monitor)
+      .with(hash_including(control_port: 33333), "system_powerdown")
   end
 
-  it "swallows ESRCH on force_kill when process already gone" do
-    allow(subject).to receive(:running?).and_return(true)
-    allow(subject).to receive(:send_powerdown)
+  it "swallows ESRCH on force_kill when the process is already gone" do
     allow(subject).to receive(:sleep)
+    allow(subject).to receive(:running?).and_return(true)
+    allow(subject).to receive(:send_monitor)
 
     pid_dir = @tmp_base.join("vagrant-qemu", vm_id)
     FileUtils.mkdir_p(pid_dir)
     File.write(pid_dir.join("qemu.pid"), "999999999")
-
     allow(Process).to receive(:kill).and_raise(Errno::ESRCH)
 
     expect { subject.stop(control_port: nil, graceful_timeout: 1) }.not_to raise_error

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-qemu
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - ppggff
@@ -59,6 +59,7 @@ files:
 - spec/e2e/advanced_network_spec.rb
 - spec/e2e/disk_spec.rb
 - spec/e2e/forwarded_port_spec.rb
+- spec/e2e/halt_spec.rb
 - spec/e2e/helper.rb
 - spec/e2e/provision_spec.rb
 - spec/e2e/reload_spec.rb