vagrant-qemu 0.3.11 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65b2cb386bb53bca93a879047e5b6a61ac690fd63a55e785b719b2b5379fb678
-  data.tar.gz: b3b4b879c90d4b7df411019f6fe8c80ea572f4751887444fc8e9e041e634ea38
+  metadata.gz: 35de3b54145ee419e9cada4bd6b879fa0e9f7faef93e27da8e750346dcd6c0b7
+  data.tar.gz: 8e0069a3cce24d59ab4723108bd54199cb6019a8a47c587601795bd6a9cc91a1
 SHA512:
-  metadata.gz: e825fc1bee4029c89a1a0acc9af2b4a2ee1f646976ac64234ef19b57078a43dd32a7330aee2c1da7b63582a3f1358fbe17e0e632e1a5337d9387be5d810ab551
-  data.tar.gz: c989f426b5232f93ca87a5f4564e36c32f42b906ff8dbe3e11f671312535993b85ac888f3a1d823f7cbb4e2c1308c733e66d33e08032a0fe2c16819bd218e5fd
+  metadata.gz: de578f059ba6ee08339738a906e366f8b8f33acc7b6389b05d68af4d365ceb6829e6d2ac7cf84214d7ff5f7af8510d657228ebd08fa0f444d40a962e23001cae
+  data.tar.gz: 5f74816cd5c18bf5ad492e546fea36d972b32585ebb0f360f1bd6cf2bbe70e475ea69365f6ff228addb5d8179feaa7944d74bfd80f4982dbd80eb7d2c7605a1b

data/CHANGELOG.md

@@ -93,3 +93,42 @@
 # 0.3.11 (2025-05-06)
 
 * Re-publish with repacked gem
+
+# 0.3.12 (2025-05-19)
+
+* Add support for extra `-drive` arguments
+* Add `extra_image_opts` to customize image creation
+* Add support for cloud-init and disks
+* Add support for resizing disk on vm setup
+
+# 0.4.0 (2026-06-12)
+
+* Advanced networking (opt-in, `advanced_network = true`): dual-NIC `private_network`
+  support via vmnet (macOS), TAP (Linux), or the QEMU `socket` netdev, with
+  deterministic MAC addresses; static IP delivered through a plugin-built cloud-init
+  NoCloud seed ISO (MAC-matched, requires cloud-init in the guest). When
+  `config.vm.cloud_init` is also set, its user-data and the generated
+  network-config are merged into a single seed
+* `net_mode = :socket` is now a thin wrapper around QEMU's `socket` netdev: the new
+  `socket_opts` option is emitted verbatim, so you pick the mode yourself —
+  `"mcast=230.0.0.1:1234"` (multicast, N-way) or `"listen=:1234"` / `"connect=host:1234"`
+  (point-to-point, no root, works on macOS where multicast does not — QEMU binds the
+  socket to the multicast group address, which Darwin rejects for sending). For
+  listen/connect you decide which VM listens and which connects (it is a 1:1 link,
+  not a hub). `mcast_addr` remains as a shortcut for the multicast address
+* Fix SSH port not updated after forwarded-port collision auto-correction
+* Persist only needed runtime state in options.yml; harden YAML loading
+  (`safe_load`); `vagrant halt` reads back the persisted control_port
+* Graceful shutdown on halt with configurable `graceful_timeout` (default 60s),
+  force kill as fallback
+* Host-aware defaults for `arch`/`machine`/`cpu`/`net_device`/`qemu_dir`: detect
+  the host arch (Apple Silicon vs Intel) and OS, default to native acceleration
+  (`hvf`/`kvm`/`whpx`) with `cpu=host` when guest arch matches the host, and to
+  `accel=tcg`/`cpu=max` when emulating; resolve `qemu_dir` from
+  `QEMU_DIR`/`HOMEBREW_PREFIX`/per-host path; skip the `qemu_dir` check for
+  x86_64 (SeaBIOS) so Intel Macs no longer fail with "Invalid qemu dir" (#59, #50)
+* Validate the QEMU binary exists before starting the VM
+* Destroy failures now surface the underlying error and preserve the machine ID
+* Warn when private_network is configured without `advanced_network`, when the
+  network backend needs sudo, and when other unsupported network types are used
+* Add test suite: unit + acceptance + e2e (`rake spec:unit|acceptance|e2e`)

data/CLAUDE.md

@@ -0,0 +1,45 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+vagrant-qemu is a Vagrant provider plugin that manages virtual machines using QEMU. It is primarily designed for Apple Silicon (aarch64) but also supports x86_64. The plugin is distributed as a Ruby gem.
+
+## Build & Development Commands
+
+```bash
+# Install dependencies (first time setup)
+bundle config set --local path 'vendor/bundle'
+bundle install
+
+# Build the gem (outputs to pkg/)
+bundle exec rake build
+
+# Install locally in Vagrant
+vagrant plugin install ./pkg/vagrant-qemu-<version>.gem
+
+# Verify installation
+vagrant plugin list | grep vagrant-qemu
+```
+
+Tests (rspec) are defined in the Gemfile but currently commented out in the Rakefile. There is no active test suite.
+
+## Architecture
+
+This is a standard Vagrant provider plugin following the Vagrant plugin v2 API. All source lives under `lib/vagrant-qemu/`.
+
+**Key components:**
+
+- **`plugin.rb`** — Registers the provider with Vagrant (name `:qemu`, box format `libvirt`), declares config and provider capabilities (disk management). Sets up i18n and logging.
+- **`config.rb`** — All provider-specific config options (`qe.memory`, `qe.arch`, `qe.cpu`, etc.). Defaults target Apple Silicon (aarch64, HVF acceleration, cortex-a72 CPU). Options set to `nil` cause the corresponding QEMU arguments to be skipped entirely.
+- **`provider.rb`** — Thin adapter between Vagrant and the Driver. Delegates actions to `Action.action_<name>`, exposes SSH info and machine state. NFS is explicitly disabled.
+- **`driver.rb`** — Core QEMU interaction: builds the `qemu-system-*` command line, manages VM lifecycle via PID files and control sockets (unix socket or TCP port). Handles import (creates qcow2 overlay images via `qemu-img create`), start, stop (sends `system_powerdown` over control socket), and destroy.
+- **`action.rb`** — Defines Vagrant action chains (up, halt, destroy, provision, reload, ssh) using `Vagrant::Action::Builder`. The `action_up` chain: HandleBox → ConfigValidate → Import (if not created) → CloudInit → Disk → Provision → Networking → StartInstance → WaitForCommunicator.
+- **`cap/disk.rb`** — Provider capability for Vagrant's disk management (qcow2 and iso formats). Creates additional disks via `qemu-img create` and attaches them to the driver.
+
+**VM state management:** State is determined by checking if the data directory exists (created?) and if the PID file references a running process (running?). VM data lives in `<data_dir>/<vm_id>/`, temp files in `~/.vagrant.d/tmp/vagrant-qemu/<vm_id>/`.
+
+**Versioning:** Single source of truth in `lib/vagrant-qemu/version.rb`.
+
+**I18n:** Locale strings in `locales/en.yml`.

data/README.md

@@ -37,6 +37,9 @@ Others:
 * Synced folder support via SMB
 * Basic operation: up, ssh, halt, destroy
 * Basic suport to forwarded ports, see [vagrant doc](https://www.vagrantup.com/docs/networking/forwarded_ports) for details
+* Support Cloud-init, see [vagrant doc](https://developer.hashicorp.com/vagrant/docs/cloud-init/usage) for details
+* Support Disks, see [vagrant doc](https://developer.hashicorp.com/vagrant/docs/disks/usage) for details
+* Advanced networking (opt-in): dual-NIC with `private_network` support via QEMU native vmnet (macOS), TAP (Linux), or a `socket` netdev — multicast (Linux/Windows) or point-to-point listen/connect (no root, works on macOS)
 
 ## Usage
 
@@ -79,26 +82,37 @@ This provider exposes a few provider-specific configuration options:
 
 * basic
   * `ssh_port` - The SSH port number used to access VM, default: `50022`
-  * `arch` - The architecture of VM, default: `aarch64`
-  * `machine` - The machine type of VM, default: `virt,accel=hvf,highmem=off`
-  * `cpu` - The cpu model of VM, default: `cortex-a72`
+  * `arch` - The architecture of VM, default: auto-detected from the host (`aarch64` on Apple Silicon, `x86_64` on Intel)
+  * `machine` - The machine type of VM, default: auto-detected from host OS + arch. For native virtualization (guest arch == host arch): `virt,highmem=on,accel=hvf` (arm64) / `q35,accel=hvf` (x86_64) on macOS, `accel=kvm` on Linux, `accel=whpx` on Windows. When emulating a non-host arch it uses `accel=tcg`.
+  * `cpu` - The cpu model of VM, default: `host` for native virtualization, `max` when emulating a non-host arch
   * `smp` - The smp setting (Simulate an SMP system with n CPUs) of VM, default: `2`
   * `memory` - The memory setting of VM, default: `4G`
+  * `disk_resize` - The target disk size of the primary disk, requires resizing of filesystem inside of VM, default: `nil`.
 * debug/expert
   * `ssh_host` - The SSH IP used to access VM, default: `127.0.0.1`
   * `ssh_auto_correct` - Auto correct port collisions for ssh port, default: `false`
-  * `net_device` - The network device, default: `virtio-net-device`
+  * `net_device` - The network device, default: auto-detected — `virtio-net-device` (arm64 `virt`) or `virtio-net-pci` (x86_64 `q35`)
   * `drive_interface` - The interface type for the main drive, default `virtio`
   * `image_path` - The path (or array of paths) to qcow2 image for box-less VM, default is nil value
   * `qemu_bin` - Path to an alternative QEMU binary, default: autodetected
-  * `qemu_dir` - The path to QEMU's install dir, default: `/opt/homebrew/share/qemu`
+  * `qemu_dir` - The path to QEMU's data/firmware dir. Default resolution order: `ENV["QEMU_DIR"]` → `${HOMEBREW_PREFIX}/share/qemu` → per-host default (`/opt/homebrew/share/qemu` on Apple Silicon, `/usr/local/share/qemu` on Intel macOS, `/usr/share/qemu` on Linux). Only consumed for aarch64 firmware; ignored (and not validated) for x86_64.
   * `extra_qemu_args` - The raw list of additional arguments to pass to QEMU. Use with extreme caution. (see "Force Multicore" below as example)
   * `extra_netdev_args` - extra, comma-separated arguments to pass to the -netdev parameter. Use with caution. (see "Force Local IP" below as example)
+  * `extra_drive_args` - Add optional extra arguments to each drive attached, default: `[]`
   * `control_port` - The port number used to control vm from vagrant, default is nil value. (nil means use unix socket)
   * `debug_port` - The port number used to export serial port of the vm for debug, default is nil value. (nil means use unix socket, see "Debug" below for details)
   * `no_daemonize` - Disable the "daemonize" mode of QEMU, default is false. (see "Windows host" below as example)
   * `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`
+* 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`
+  * `vmnet_interface` - Physical interface for vmnet-bridged mode, default: `en0`
+  * `tap_device` - TAP device name for Linux tap backend, default: `nil` (uses `tap0`)
+  * `mcast_addr` - Convenience shortcut for the `:socket` backend's multicast address, default: `nil` (uses `230.0.0.1:1234`)
+  * `socket_opts` - Raw options for the `:socket` netdev, emitted verbatim as `-netdev socket,id=netN,<socket_opts>`. You pick the mode: `"mcast=230.0.0.1:1234"` (multicast, N-way), `"listen=:1234"` / `"connect=127.0.0.1:1234"` (point-to-point; you decide which VM listens and which connects — the no-root, macOS-friendly path). Overrides `mcast_addr`. Default: `nil` (falls back to multicast)
 
 ### Usage
 
@@ -169,6 +183,11 @@ end
 
 4. Work with a x86_64 box (basic config)
 
+On an **Intel Mac** (or Linux x86_64 host) these defaults are now auto-detected,
+so a plain `config.vm.box = "..."` with no provider overrides is usually enough.
+The explicit settings below are only needed to **emulate** x86_64 on an Apple
+Silicon host (cross-arch → TCG):
+
 ```
 Vagrant.configure(2) do |config|
   config.vm.box = "centos/7"
@@ -273,6 +292,109 @@ Thanks example from @Leandros.
 
 See [pr#73](https://github.com/ppggff/vagrant-qemu/pull/73) for details.
 
+11. Improved VM I/O performance
+
+When creating the disks that are attached, each disk is an id assign in order
+they appear in the `Vagrantfile`. The primary disk has the `id` of `disk0`.
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider "qemu" do |qe|
+    # Use a `none` drive interface.
+    qe.drive_interface = "none"
+    qe.extra_drive_args = "cache=none,aio=threads"
+
+    # To improve I/O performance, create a separate I/O thread.
+    # We refer to the primary disk as `disk0`.
+    qe.extra_qemu_args = %w(
+        -object iothread,id=io1
+        -device virtio-blk-pci,drive=disk0,iothread=io1
+    )
+  end
+end
+```
+
+See the [QEMU Documentation](https://www.qemu.org/docs/master/devel/multiple-iothreads.html) and [heiko-sieger.info/tuning-vm-disk-performance/](https://www.heiko-sieger.info/tuning-vm-disk-performance/) for more details.
+
+12. Advanced networking with private_network
+
+Pick a backend with `net_mode`: QEMU's native vmnet.framework on macOS (requires sudo), TAP on Linux, or the `socket` netdev. The `:socket` backend is a thin wrapper around QEMU's `socket` netdev — you choose the mode in `socket_opts`: `mcast=` (multicast, N-way, Linux/Windows) or `listen=`/`connect=` (point-to-point, no root, works on macOS). The plugin creates two NICs: NIC 0 (user-mode for SSH and port forwarding) and NIC 1 (platform backend for VM networking). The static IP is delivered via a cloud-init NoCloud seed ISO that the plugin builds and attaches automatically; the NICs are matched by MAC address, never by interface order.
+
+For VM-to-VM networking on macOS without sudo, use `:socket` with a `listen`/`connect` pair — you decide which VM listens and which connects:
+
+```ruby
+Vagrant.configure("2") do |config|
+  PORT = 12399
+  # vm1 listens; define it first so it is up before vm2 connects.
+  config.vm.define "vm1" do |c|
+    c.vm.box = "perk/ubuntu-2204-arm64"  # an aarch64 cloud-init box
+    c.vm.network "private_network", ip: "192.168.105.51"
+    c.vm.provider "qemu" do |qe|
+      qe.advanced_network = true
+      qe.net_mode = :socket
+      qe.socket_opts = "listen=127.0.0.1:#{PORT}"
+      qe.ssh_auto_correct = true
+    end
+  end
+  # vm2 connects to vm1.
+  config.vm.define "vm2" do |c|
+    c.vm.box = "perk/ubuntu-2204-arm64"
+    c.vm.network "private_network", ip: "192.168.105.52"
+    c.vm.provider "qemu" do |qe|
+      qe.advanced_network = true
+      qe.net_mode = :socket
+      qe.socket_opts = "connect=127.0.0.1:#{PORT}"
+      qe.ssh_auto_correct = true
+    end
+  end
+end
+```
+
+A single VM with a static IP (vmnet is the default backend on macOS when `net_mode` is `:auto`):
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "ppggff/centos-7-aarch64-2009-4K"
+  config.vm.network "private_network", ip: "192.168.105.10"
+
+  config.vm.provider "qemu" do |qe|
+    qe.advanced_network = true
+    # qe.net_mode = :vmnet_shared  # default on macOS when :auto
+  end
+end
+```
+
+Notes:
+* The guest image must include cloud-init, otherwise the static IP is silently not applied
+* On macOS, vmnet requires root: run `sudo vagrant up` (and the other lifecycle commands such as `halt`/`reload`/`destroy`), because the plugin launches QEMU as a child of the Vagrant process and does not elevate it on its own. The plugin warns when vmnet is selected and Vagrant is not running as root.
+* Side effect of running under `sudo`: QEMU and everything it writes become **root-owned** — the per-VM data directory (`.vagrant/machines/<name>/qemu/` in your project) and any box Vagrant downloads while elevated (`~/.vagrant.d/boxes/<box>/`). A later command run **without** `sudo` then fails with `EACCES` — e.g. a plain `vagrant status`/`up`, an unprivileged test run, or switching to a rootless backend — often on the box's `box_update_check` file. To handle it, either keep using `sudo` consistently for that environment, or restore ownership:
+  ```sh
+  sudo chown -R "$(id -un)":staff ~/.vagrant.d/boxes/<box> .vagrant
+  ```
+  Pre-adding boxes as your normal user (`vagrant box add <box>`) before the first `sudo vagrant up` also avoids the box ending up root-owned.
+* To avoid root (and this side effect) entirely on macOS, use [`socket_vmnet`](https://github.com/lima-vm/socket_vmnet) — a small root helper daemon you install once, which QEMU then connects to as a normal user (the approach Lima/Colima/minikube take). The `com.apple.developer.networking.vmnet` entitlement could also bypass root in principle, but it is a *restricted* Apple entitlement that requires an Apple-provisioned signing certificate and cannot be ad-hoc / self-signed onto Homebrew's QEMU, so it is not a practical option for individual users.
+* Without `advanced_network = true`, the `private_network` configuration is ignored with a warning
+* When only one NIC is needed (no `private_network`), no cloud-init seed is attached, avoiding compatibility issues
+* Combining `advanced_network` with `config.vm.cloud_init` is supported: the plugin merges your user-data and the generated network-config into a single NoCloud seed
+* The Linux `:tap` backend expects a pre-created tap device attached to a bridge, e.g.:
+  `sudo ip tuntap add tap0 mode tap && sudo ip link set tap0 master br0 && sudo ip link set tap0 up`
+* `socket_opts = "mcast=..."` gives N-way VM-to-VM on Linux/Windows, but does **not** work on macOS: QEMU binds the netdev socket to the multicast group address, which the Darwin socket stack refuses to send from (`EADDRNOTAVAIL`). On macOS use a `listen`/`connect` pair (no root) or vmnet (sudo).
+* `socket_opts = "listen=..."` / `"connect=..."` is a point-to-point QEMU TCP link and connects **exactly two** VMs (QEMU's listening socket accepts a single connection — it is not a hub). You choose which VM listens and which connects. The listener must be running before the connector starts, so define the listener first and bring the environment up together (`vagrant up`); starting a connector alone, or reloading the listener, drops the link.
+
+Platform support:
+
+| Platform | Backend (`net_mode`) | Host ↔ VM | VM ↔ VM | Root? | External dependency |
+|----------|---------|:---------:|:-------:|:-----:|:-------------------:|
+| macOS    | `:vmnet_shared`/`_host`/`_bridged` | Yes | Yes | sudo (or socket_vmnet) | None (QEMU >= 7.0) |
+| macOS    | `:socket` (`listen`/`connect`) | No (use port forwarding) | Yes (2 VMs) | No | None |
+| Linux    | `:tap` + bridge | Yes | Yes | sudo | Pre-created tap device + bridge (`ip` command) |
+| Linux    | `:socket` (`mcast`) | No (use port forwarding) | Yes | No | None |
+| Windows  | `:socket` (`mcast`) | No (use port forwarding) | Yes | No | None |
+
+(`socket_opts = "mcast=..."` is not usable on macOS — see the note above; use a `listen`/`connect` pair there.)
+
 ## Debug
 
 Serial port is exported to unix socket: `<user_home>/.vagrant.d/tmp/vagrant-qemu/<id>/qemu_socket_serial`, or `debug_port`.
@@ -294,17 +416,84 @@ To send ctrl+c to GuestOS from `nc`, try:
 
 ## Build
 
-To build the `vagrant-qemu` plugin, clone this repository out, and use
-[Bundler](http://gembundler.com) to get the dependencies:
+To build the `vagrant-qemu` plugin 
 
-```
-bundle
-```
+**Development Environment:**
+
+Ensure your development environment has the necessary tools installed, such as:
+
+* **Ruby**:
+    * [Ruby installation](https://www.ruby-lang.org/en/documentation/installation/)
+    * [Ruby Version Manager (RVM)](https://rvm.io/rvm/install)
+    * [Ruby Installer for Windows](https://rubyinstaller.org/)
+* [Bundler](https://bundler.io/):
+    ```sh
+    gem install bundler
+    ```
+* [Rake](https://github.com/ruby/rake)
+    ```sh
+    gem install rake
+    ```
+
+1. Clone this repository:
+    ```sh
+    git clone https://github.com/ppggff/vagrant-qemu.git
+    cd vagrant-qemu
+    ```
+
+2. Use [bundler](http://gembundler.com) to install the necessary dependencies to ensure all required Ruby gems are available for buidling the plugin out
+    ```sh
+    bundle config set --local path 'vendor/bundle'
+    bundle install
+    ```
+    > This command tells Bundler to install gems in the vendor/bundle directory within your project.
 
-Once you have the dependencies, build with `rake`:
+3. Use `rake` to build the plugin. This command will package your changes into a gem file:
 
+    ```sh
+    bundle exec rake build
+    ```
+    > After running this command, you should see a `.gem` file created in the `pkg` directory within the repository. This file represents your built plugin.
+
+4. Use `vagrant plugin install` to install the plugin from the local `.gem` file. This ensures that Vagrant uses the locally built version.
+    
+    ```sh
+    vagrant plugin install ./pkg/vagrant-qemu-<version>.gem
+    ```
+
+    > Replace `<version>` with the actual version number of the locally built `.gem` file
+
+### Check Installed Plugins
+
+After installation, verify that the locally built `vagrant-qemu` plugin is installed by running:
+
+```sh
+vagrant plugin list | grep vagrant-qemu
 ```
+
+> This command will list all installed plugins, and you should see the vagrant-qemu plugin with the locally built version.
+
+### Running Tests
+
+```sh
+# Unit tests (fast, no QEMU needed)
+bundle exec rake spec:unit
+
+# Acceptance tests (mock QEMU, no real VM)
+bundle exec rake spec:acceptance
+
+# End-to-end tests (requires QEMU and a box image). e2e exercises the
+# INSTALLED plugin — rebuild and reinstall first (the suite fails fast on
+# a version mismatch):
 bundle exec rake build
+vagrant plugin install ./pkg/vagrant-qemu-<version>.gem
+TEST_QEMU=1 bundle exec rake spec:e2e
+
+# End-to-end with vmnet (requires sudo + macOS; needs an aarch64 cloud-init box)
+TEST_QEMU=1 TEST_VMNET=1 TEST_BOX_CLOUDINIT=perk/ubuntu-2204-arm64 sudo -E bundle exec rake spec:e2e
+
+# All tests
+bundle exec rake spec
 ```
 
 ## Known issue / Troubleshooting
@@ -367,25 +556,35 @@ If you get this error when running `vagrant up`
 
 ### 4. The box you're using with the QEMU provider ('default') is invalid
 
-This may cause by invalid default qemu dir (`/opt/homebrew/share/qemu`).
-
-You can find the correct one by:
+`qemu_dir` is auto-detected (Homebrew prefix / per-host default) and is only
+needed for **aarch64** firmware — x86_64 boots on SeaBIOS and no longer
+validates it. If detection still picks the wrong path for an aarch64 box
+(e.g. a MacPorts or custom QEMU install), set it explicitly. Find the correct
+one with:
 ```
 echo `brew --prefix`/share/qemu
 ```
 
-And then set it (for example `/usr/local/share/qemu`) in the `Vagrantfile` as:
+Then either export `QEMU_DIR` / `HOMEBREW_PREFIX`, or set it in the `Vagrantfile`:
 ```
 config.vm.provider "qemu" do |qe|
   qe.qemu_dir = "/usr/local/share/qemu"
 end
 ```
 
+### 5. `conflicting dependencies logger (= 1.6.0) and logger (= 1.6.1)` when installing the plugin
+
+This is a Vagrant 2.4.2 packaging bug (bundled `logger` gem version conflict),
+not a problem with this plugin — see
+[hashicorp/vagrant#13534](https://github.com/hashicorp/vagrant/issues/13534).
+Upgrade Vagrant to **2.4.3 or newer** (the Homebrew cask may lag; install the
+official build from [vagrantup.com](https://www.vagrantup.com/downloads) if
+needed). Do **not** work around it by pinning `logger` in a Gemfile — that tends
+to deepen the conflict.
+
 ## TODO
 
 * Support NFS shared folder
 * Support package VM to box
 * More configures
-* Better error messages
-* Network
 * GUI mode

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'bundler/setup'
-# require 'rspec/core/rake_task'
+require 'rspec/core/rake_task'
 
 # Immediately sync all stdout so that tools like buildbot can
 # immediately load in the output.
@@ -14,12 +14,29 @@ Dir.chdir(File.expand_path("../", __FILE__))
 # publishing.
 Bundler::GemHelper.install_tasks
 
-# Install the `spec` task so that we can run tests.
-# RSpec::Core::RakeTask.new(:spec) do |t|
-#   t.rspec_opts = "--order defined"
-# end
-# Default task is to run the unit tests
-# task :default => :spec
+# Test tasks
+namespace :spec do
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = "spec/unit/**/*_spec.rb"
+    t.rspec_opts = "--order defined"
+  end
+
+  RSpec::Core::RakeTask.new(:acceptance) do |t|
+    t.pattern = "spec/acceptance/**/*_spec.rb"
+    t.rspec_opts = "--order defined"
+  end
+
+  RSpec::Core::RakeTask.new(:e2e) do |t|
+    t.pattern = "spec/e2e/**/*_spec.rb"
+    t.rspec_opts = "--order defined"
+  end
+end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.rspec_opts = "--order defined"
+end
 
 # build
 task :default => :build

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

@@ -0,0 +1,123 @@
+require "fileutils"
+require "tmpdir"
+require "yaml"
+
+require "vagrant/action/builtin/cloud_init_setup"
+
+require_relative "../network"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      # Carries the cloud-init network-config for the advanced-network private
+      # NIC into a NoCloud cidata seed. The ISO build is delegated to the
+      # :create_iso host capability and the attach goes through the provider
+      # disk capability (cap/disk.rb).
+      #
+      # NoCloud reads user-data, meta-data and network-config from a single
+      # filesystem labelled "cidata"; two cidata volumes are ambiguous. So when
+      # core CloudInitSetup (which runs earlier in the chain) has already built
+      # a user-data seed, we rebuild that same ISO in place with network-config
+      # added instead of attaching a second seed.
+      class CloudInitNetwork
+        # Disk name core Vagrant::Action::Builtin::CloudInitSetup gives its
+        # user-data seed.
+        CORE_SEED_DISK_NAME = "vagrant-cloud_init-disk".freeze
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_qemu::action::cloud_init_network")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          pn = machine.config.vm.networks
+            .select { |t, _| t == :private_network }
+            .map { |_, opts| opts }
+            .first
+
+          if machine.provider_config.advanced_network && pn && pn[:ip]
+            existing = machine.config.vm.disks.find do |d|
+              d.type == :dvd && d.name == CORE_SEED_DISK_NAME
+            end
+
+            if existing
+              merge_into_seed(machine, env, pn, existing.file)
+            else
+              attach_network_seed(machine, env, pn)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        # No core cloud-init seed: build our own network-only seed and attach
+        # it as a fresh :dvd disk.
+        def attach_network_seed(machine, env, pn)
+          iso_path = build_seed(machine, env, pn,
+            user_data: "#cloud-config\n",
+            file_destination: machine.data_dir.join("vagrant-qemu-network.iso"))
+
+          machine.config.vm.disk :dvd, file: iso_path.to_s, name: "vagrant-qemu-network-disk"
+          machine.config.vm.disks.each do |d|
+            d.finalize! if d.type == :dvd && d.file == iso_path.to_s
+          end
+          @logger.info("Attached cloud-init network seed ISO at #{iso_path}")
+        end
+
+        # Core CloudInitSetup already built a user-data seed and attached it.
+        # Rebuild that same ISO in place, carrying both the user-data and our
+        # network-config in one cidata volume. No second disk is registered.
+        def merge_into_seed(machine, env, pn, iso_path)
+          ud_cfgs = machine.config.vm.cloud_init_configs
+            .select { |c| c.type == :user_data }
+          setup = Vagrant::Action::Builtin::CloudInitSetup.new(->(_) {}, env)
+          user_data = setup.setup_user_data(machine, env, ud_cfgs).to_s
+
+          FileUtils.rm_f(iso_path)
+          build_seed(machine, env, pn,
+            user_data: user_data,
+            file_destination: Pathname.new(iso_path))
+          @logger.info("Merged cloud-init network seed into #{iso_path}")
+        end
+
+        # Write a NoCloud cidata seed (network-config + meta-data + user-data)
+        # and build the ISO via the :create_iso host capability. Returns the
+        # ISO path.
+        def build_seed(machine, env, pn, user_data:, file_destination:)
+          if !env[:env].host.capability?(:create_iso)
+            raise Vagrant::Errors::CreateIsoHostCapNotFound
+          end
+
+          mac0, mac1 = Network.nic_macs(machine.id, pn)
+          network_config = Network.build_network_config(
+            mac0: mac0,
+            mac1: mac1,
+            ip: pn[:ip],
+            netmask: pn[:netmask] || "255.255.255.0"
+          )
+
+          source_dir = Pathname.new(Dir.mktmpdir("vagrant-qemu-network-seed"))
+          begin
+            File.write(source_dir.join("network-config"), network_config)
+            File.write(source_dir.join("meta-data"),
+              { "instance-id" => "i-#{machine.id.to_s.split("-").join}" }.to_yaml)
+            File.write(source_dir.join("user-data"), user_data)
+
+            env[:env].host.capability(
+              :create_iso,
+              source_dir,
+              file_destination: file_destination,
+              volume_id: "cidata"
+            )
+          ensure
+            FileUtils.remove_entry(source_dir)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,13 @@ module VagrantPlugins
 
         def call(env)
           env[:ui].info(I18n.t("vagrant_qemu.destroying"))
-          env[:machine].provider.driver.delete
+          begin
+            env[:machine].provider.driver.delete
+          rescue => e
+            # Vagrant errors only render error_key translations; a bare
+            # String here would be silently dropped.
+            raise Errors::DestroyError, message: e.message
+          end
           env[:machine].id = nil
 
           @app.call(env)

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

@@ -61,12 +61,17 @@ module VagrantPlugins
             @logger.info("Found box image path: #{img_info}")
           end
 
+          # qemu_dir holds the firmware images, which are only consumed for the
+          # aarch64 target (see driver.rb). x86_64 boots on SeaBIOS and never
+          # touches qemu_dir, so don't let a missing dir block it.
           qemu_dir = Pathname.new(env[:machine].provider_config.qemu_dir)
-          if !qemu_dir.directory?
-            @logger.error("Invalid qemu dir: #{qemu_dir}")
-            raise Errors::ConfigError, err: "Invalid qemu dir: #{qemu_dir}"
-          else
-            @logger.info("Found qemu dir: #{qemu_dir}")
+          if env[:machine].provider_config.arch == "aarch64"
+            if !qemu_dir.directory?
+              @logger.error("Invalid qemu dir: #{qemu_dir}")
+              raise Errors::ConfigError, err: "Invalid qemu dir: #{qemu_dir}"
+            else
+              @logger.info("Found qemu dir: #{qemu_dir}")
+            end
           end
 
           env[:ui].output("Importing a QEMU instance")
@@ -75,7 +80,9 @@ module VagrantPlugins
             :image_path => image_path,
             :qemu_dir => qemu_dir,
             :arch => env[:machine].provider_config.arch,
-            :firmware_format => env[:machine].provider_config.firmware_format
+            :firmware_format => env[:machine].provider_config.firmware_format,
+            :extra_image_opts => env[:machine].provider_config.extra_image_opts,
+            :disk_resize => env[:machine].provider_config.disk_resize,
           }
 
           env[:ui].detail("Creating and registering the VM...")

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

@@ -24,9 +24,9 @@ module VagrantPlugins
             env[:machine_state_id] = :not_created
           end
 
-          # Update ssh_port if needed
+          # Update driver's runtime ssh_port from persisted options
           if env[:machine_state_id] == :running
-            env[:machine].provider_config.ssh_port = env[:machine].provider.driver.get_ssh_port(env[:machine].provider_config.ssh_port)
+            env[:machine].provider.driver.get_ssh_port(env[:machine].provider_config.ssh_port)
           end
           @app.call(env)
         end