vagrant-qemu 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 56d15ffaaea610e07a3d494ef9935dc75469989a5c2b586106fcd9b0c75e41c4
+  data.tar.gz: d8ce98156eeff8fe8692ece6c0254db233bfcc3ea136dbd767b9acdd3f858f6d
+SHA512:
+  metadata.gz: 7845ce71e9f0403ff35ebe4def750fef772a7736fb225262a71005fb1a944792b2bcc2ccec7f789b11b82a2b243f5b65bb833967155144bb7421ccb09d7730e3
+  data.tar.gz: 82272e1a35fa6ee973468040784d01d33a1d3354da89a784119c44350ace75161c9974d1de5f3ebd63247abe673232044f37b7ce203d3a723016797a1e78d7fd

data/.gitignore

@@ -0,0 +1,22 @@
+# OS-specific
+.DS_Store
+
+# editors
+*.swp
+
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+vendor
+
+# Vagrant
+.vagrant
+Vagrantfile
+!example_box/Vagrantfile
+
+# RVM files for gemset/ruby setting
+.ruby-*
+.rvmrc

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# 0.1.0 (2021-12-15)
+
+* Initial release.
+
+# 0.1.1 (2021-12-30)
+
+* Works with basic functions.
+
+# 0.1.2 (2022-01-06)
+
+* Support vm without box.

data/Gemfile

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git"
+
+  gem "rake"
+  gem "rspec", "~> 3.4"
+  gem "rspec-its"
+end
+
+group :plugins do
+  gem "vagrant-qemu" , path: "."
+end

data/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2021 ppggff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,128 @@
+# Vagrant QEMU Provider
+
+This is a Vagrant plugin that adds a simple QEMU provider to Vagrant, allowing Vagrant
+to control and provision machines using QEMU.
+
+**Notes: test with Apple Silicon / M1 and CentOS aarch64 image only**
+
+## Features
+
+* Import from a Libvirt vagrant box or qcow2 image
+* Start VM without GUI
+* SSH into VM
+* Provision the instances with any built-in Vagrant provisioner
+* Synced folder support via SMB
+* Basic operation: up, ssh, halt, destroy
+
+## Usage
+
+Make sure QEMU is installed, if not:
+
+```
+brew install qemu
+```
+
+Install plugin:
+
+```
+vagrant plugin install vagrant-qemu-x.x.x.gem
+```
+
+Prepare a `Vagrantfile`, and start:
+
+```
+vagrant up --provider qemu
+```
+
+Notes:
+* may need password to setup SMB on Mac,
+  see [vagrant doc](https://www.vagrantup.com/docs/synced-folders/smb) for details
+* need username/password to access shared folder
+
+## Box format
+
+Same as [vagrant-libvirt version-1](https://github.com/vagrant-libvirt/vagrant-libvirt#version-1):
+
+* qcow2 image file named `box.img`
+* `metadata.json` file describing box image (provider, virtual_size, format)
+* `Vagrantfile` that does default settings
+
+## Configuration
+
+This provider exposes a few provider-specific configuration options:
+
+* `ssh_port` - The SSH port number used to access VM (IP is 127.0.0.1),
+  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`
+* `smp` - The smp setting (Simulate an SMP system with n CPUs) of VM, default: `2`
+* `memory` - The memory setting of VM, default: `4G`
+* `image_path` - The path to qcow2 image for box-less VM, default is nil value
+* `qemu_dir` - The path to QEMU's install dir, default: `/opt/homebrew/share/qemu`
+
+These can be set like typical provider-specific configuration:
+
+```
+# Basic Vagrant config (API version 2)
+Vagrant.configure(2) do |config|
+  # ... other stuff
+
+  config.vm.provider "qemu" do |qe|
+    qe.memory = "8G"
+  end
+end
+```
+
+## Example
+
+1. With a local box
+
+```
+# Basic Vagrant config (API version 2)
+Vagrant.configure(2) do |config|
+  config.vm.box = "test-box"
+  config.vm.box_url = "file:///Users/xxx/test.box"
+  config.vm.box_check_update = false
+end
+```
+
+2. With a local qcow2
+
+```
+# Basic Vagrant config (API version 2)
+Vagrant.configure(2) do |config|
+  config.vm.provider "qemu" do |qe, override|
+    override.ssh.username = "xxx"
+    override.ssh.password = "vagrant"
+
+    qe.image_path = "/Users/xxx/test.qcow2"
+  end
+end
+```
+
+## Build
+
+To build the `vagrant-qemu` plugin, clone this repository out, and use
+[Bundler](http://gembundler.com) to get the dependencies:
+
+```
+bundle
+```
+
+Once you have the dependencies, build with `rake`:
+
+```
+bundle exec rake build
+```
+
+## TODO
+
+* Support example image
+* Support NFS shared folder
+* Support package VM to box
+* Test on more architectures
+* More configures
+* Better error messages
+* Network
+* GUI mode

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'bundler/setup'
+# require 'rspec/core/rake_task'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Change to the directory of this file.
+Dir.chdir(File.expand_path("../", __FILE__))
+
+# This installs the tasks that help with gem creation and
+# 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
+
+# build
+task :default => :build

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module QEMU
+    module Action
+      class Destroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_qemu.destroying"))
+          env[:machine].provider.driver.delete
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require "log4r"
+require "pathname"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      class Import
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_qemu::action::import")
+        end
+
+        def call(env)
+          image_path = nil
+          if env[:machine].provider_config.image_path
+            image_path = Pathname.new(env[:machine].provider_config.image_path)
+          elsif env[:machine].box
+            image_path = env[:machine].box.directory.join("box.img")
+          end
+
+          if !image_path || !image_path.file?
+            @logger.error("Invalid box image path: #{image_path}")
+            raise Errors::BoxInvalid, name: env[:machine].name
+          else
+            @logger.info("Found box image path: #{image_path}")
+          end
+
+          qemu_dir = Pathname.new(env[:machine].provider_config.qemu_dir)
+          if !qemu_dir.directory?
+            @logger.error("Invalid qemu dir: #{qemu_dir}")
+            raise Errors::BoxInvalid, name: env[:machine].name
+          else
+            @logger.info("Found qemu dir: #{qemu_dir}")
+          end
+
+          env[:ui].output("Importing a QEMU instance")
+
+          options = {
+            :image_path => image_path,
+            :qemu_dir => qemu_dir,
+          }
+
+          env[:ui].detail("Creating and registering the VM...")
+          server = env[:machine].provider.driver.import(options)
+
+          env[:ui].detail("Successfully imported VM")
+          env[:machine].id = server[:id]
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module QEMU
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_qemu.already_status", :status => "created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module QEMU
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_qemu.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module QEMU
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_qemu.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "log4r"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_qemu::action::read_state")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:machine_state_id] = env[:machine].provider.driver.get_current_state
+
+            # If the machine isn't created, then our ID is stale, so just
+            # mark it as not created.
+            if env[:machine_state_id] == :not_created
+              env[:machine].id = nil
+            end
+          else
+            env[:machine_state_id] = :not_created
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "log4r"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      # This starts a stopped instance.
+      class StartInstance
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_qemu::action::start_instance")
+        end
+
+        def call(env)
+          options = {
+            :ssh_port => env[:machine].provider_config.ssh_port,
+            :arch => env[:machine].provider_config.arch,
+            :machine => env[:machine].provider_config.machine,
+            :cpu => env[:machine].provider_config.cpu,
+            :smp => env[:machine].provider_config.smp,
+            :memory => env[:machine].provider_config.memory,
+          }
+
+          env[:ui].output(I18n.t("vagrant_qemu.starting"))
+          env[:machine].provider.driver.start(options)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module QEMU
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_qemu.stopping"))
+          env[:machine].provider.driver.stop
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module QEMU
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_qemu.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/action.rb

@@ -0,0 +1,174 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      def self.action_package
+        lambda do |env|
+          raise Errors::NotSupportedError
+        end
+      end
+
+      # This action is called to halt the remote machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use StopInstance
+          end
+        end
+      end
+
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b2.use Call, IsState, :not_created do |env2, b3|
+                if env2[:result]
+                  b3.use MessageNotCreated
+                  next
+                end
+
+                b3.use ProvisionerCleanup, :before if defined?(ProvisionerCleanup)
+                b3.use StopInstance
+                b3.use Destroy
+                b3.use SyncedFolderCleanup
+              end
+            else
+              b2.use MessageWillNotDestroy
+            end
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+          end
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ReadState
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :running do |env1, b1|
+            if env1[:result]
+              b1.use action_provision
+              next
+            end
+
+            b1.use Provision
+            b1.use SyncedFolderCleanup
+            b1.use SyncedFolders
+            b1.use WarnNetworks
+            b1.use SetHostname
+            b1.use StartInstance
+            b1.use WaitForCommunicator, [:running]
+          end
+        end
+      end
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBox
+          b.use ConfigValidate
+          b.use BoxCheckOutdated
+          b.use Call, IsState, :not_created do |env1, b1|
+            if env1[:result]
+              b1.use Import
+            end
+
+            b1.use action_start
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use action_halt
+            b2.use action_start
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :Import, action_root.join("import")
+      autoload :StartInstance, action_root.join("start_instance")
+      autoload :StopInstance, action_root.join("stop_instance")
+      autoload :Destroy, action_root.join("destroy")
+      autoload :TimedProvision, action_root.join("timed_provision") # some plugins now expect this action to exist
+      autoload :WarnNetworks, action_root.join("warn_networks")
+    end
+  end
+end

data/lib/vagrant-qemu/config.rb

@@ -0,0 +1,53 @@
+require "vagrant"
+
+module VagrantPlugins
+  module QEMU
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :ssh_port
+      attr_accessor :arch
+      attr_accessor :machine
+      attr_accessor :cpu
+      attr_accessor :smp
+      attr_accessor :memory
+      attr_accessor :image_path
+      attr_accessor :qemu_dir
+
+      def initialize
+        @ssh_port = UNSET_VALUE
+        @arch = UNSET_VALUE
+        @machine = UNSET_VALUE
+        @cpu = UNSET_VALUE
+        @smp = UNSET_VALUE
+        @memory = UNSET_VALUE
+        @image_path = UNSET_VALUE
+        @qemu_dir = UNSET_VALUE
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def merge(other)
+        super.tap do |result|
+        end
+      end
+
+      def finalize!
+        @ssh_port = 50022 if @ssh_port == UNSET_VALUE
+        @arch = "aarch64" if @arch == UNSET_VALUE
+        @machine = "virt,accel=hvf,highmem=off" if @machine == UNSET_VALUE
+        @cpu = "cortex-a72" if @cpu == UNSET_VALUE
+        @smp = "2" if @smp == UNSET_VALUE
+        @memory = "4G" if @memory == UNSET_VALUE
+        @image_path = nil if @image_path == UNSET_VALUE
+        @qemu_dir = "/opt/homebrew/share/qemu" if @qemu_dir == UNSET_VALUE
+      end
+
+      def validate(machine)
+        # errors = _detected_errors
+        errors = []
+        { "QEMU Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/driver.rb

@@ -0,0 +1,158 @@
+require 'securerandom'
+
+require "vagrant/util/busy"
+require "vagrant/util/subprocess"
+
+require_relative "plugin"
+
+module VagrantPlugins
+  module QEMU
+	  class Driver
+      # @return [String] VM ID
+      attr_reader :vm_id
+      attr_reader :data_dir
+
+      def initialize(id, dir)
+        @vm_id = id
+        @data_dir = dir
+      end
+
+      def get_current_state
+        case
+        when running?
+          :running
+        when created?
+          :stopped
+        else
+          :not_created
+        end
+      end
+
+      def delete
+        if created?
+          id_dir = @data_dir.join(@vm_id)
+          FileUtils.rm_rf(id_dir)
+        end
+      end
+
+      def start(options)
+        if !running?
+          id_dir = @data_dir.join(@vm_id)
+          image_path = id_dir.join("linked-box.img").to_s
+          unix_socket_path = id_dir.join("qemu_socket").to_s
+          pid_file = id_dir.join("qemu.pid").to_s
+
+          cmd = []
+          cmd += %W(qemu-system-#{options[:arch]})
+
+          # basic
+          cmd += %W(-machine #{options[:machine]})
+          cmd += %W(-cpu #{options[:cpu]})
+          cmd += %W(-smp #{options[:smp]})
+          cmd += %W(-m #{options[:memory]})
+          cmd += %W(-device virtio-net-device,netdev=net0)
+          cmd += %W(-netdev user,id=net0,hostfwd=tcp::#{options[:ssh_port]}-:22)
+
+          # drive
+          cmd += %W(-drive if=virtio,format=qcow2,file=#{image_path})
+          if options[:arch] == "aarch64"
+            fm1_path = id_dir.join("edk2-aarch64-code.fd").to_s
+            fm2_path = id_dir.join("edk2-arm-vars.fd").to_s
+            cmd += %W(-drive if=pflash,format=raw,file=#{fm1_path},readonly=on)
+            cmd += %W(-drive if=pflash,format=raw,file=#{fm2_path})
+          end
+
+          # control
+          cmd += %W(-chardev socket,id=mon0,path=#{unix_socket_path},server=on,wait=off)
+          cmd += %W(-mon chardev=mon0,mode=readline)
+          cmd += %W(-pidfile #{pid_file})
+          cmd += %W(-serial null -parallel null -monitor none -display none -vga none)
+          cmd += %W(-daemonize)
+
+          execute(*cmd)
+        end
+      end
+
+      def stop
+        if running?
+          id_dir = @data_dir.join(@vm_id)
+          unix_socket_path = id_dir.join("qemu_socket").to_s
+          sent = false
+          execute("nc", "-w", "5", "-U", unix_socket_path) do |type, data|
+            case type
+            when :stdin
+              if !sent
+                data.write("system_powerdown\n")
+                sent = true
+              end
+            end
+          end
+        end
+      end
+
+      def import(options)
+        new_id = SecureRandom.urlsafe_base64(8)
+
+        # Make dir
+        id_dir = @data_dir.join(new_id)
+        FileUtils.mkdir_p(id_dir)
+
+        # Prepare firmware
+        execute("cp", options[:qemu_dir].join("edk2-aarch64-code.fd").to_s, id_dir.join("edk2-aarch64-code.fd").to_s)
+        execute("cp", options[:qemu_dir].join("edk2-arm-vars.fd").to_s, id_dir.join("edk2-arm-vars.fd").to_s)
+
+        # Create image
+        execute("qemu-img", "create", "-f", "qcow2", "-F", "qcow2", "-b", options[:image_path].to_s, id_dir.join("linked-box.img").to_s)
+
+        server = {
+          :id => new_id,
+        }
+      end
+
+      def created?
+        result = @data_dir.join(@vm_id).directory?
+      end
+
+      def running?
+        pid_file = @data_dir.join(@vm_id).join("qemu.pid")
+        return false if !pid_file.file?
+
+        begin
+          Process.getpgid(File.read(pid_file).to_i)
+          true
+        rescue Errno::ESRCH
+          false
+        end
+      end
+
+      def execute(*cmd, **opts, &block)
+        # Append in the options for subprocess
+        cmd << { notify: [:stdout, :stderr, :stdin] }
+
+        interrupted  = false
+        int_callback = ->{ interrupted = true }
+        result = ::Vagrant::Util::Busy.busy(int_callback) do
+          ::Vagrant::Util::Subprocess.execute(*cmd, &block)
+        end
+
+        result.stderr.gsub!("\r\n", "\n")
+        result.stdout.gsub!("\r\n", "\n")
+
+        if result.exit_code != 0 && !interrupted
+          raise Errors::ExecuteError,
+            command: cmd.inspect,
+            stderr: result.stderr,
+            stdout: result.stdout
+        end
+
+        if opts
+          if opts[:with_stderr]
+            return result.stdout + " " + result.stderr
+          else
+            return result.stdout
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/errors.rb

@@ -0,0 +1,31 @@
+require "vagrant"
+
+module VagrantPlugins
+  module QEMU
+    module Errors
+      class VagrantQEMUError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_qemu.errors")
+      end
+
+      class RsyncError < VagrantQEMUError
+        error_key(:rsync_error)
+      end
+
+      class MkdirError < VagrantQEMUError
+        error_key(:mkdir_error)
+      end
+
+      class NotSupportedError < VagrantQEMUError
+        error_key(:not_supported)
+      end
+
+      class BoxInvalid < VagrantQEMUError
+        error_key(:box_invalid)
+      end
+
+      class ExecuteError < VagrantQEMUError
+        error_key(:execute_error)
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant QEMU plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant QEMU plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module QEMU
+    class Plugin < Vagrant.plugin("2")
+      name "QEMU"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in QEMU.
+      DESC
+
+      config(:qemu, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:qemu, box_format: "libvirt", box_optional: true, parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", QEMU.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_qemu")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/provider.rb

@@ -0,0 +1,76 @@
+require "log4r"
+require "vagrant"
+
+require_relative "driver"
+
+module VagrantPlugins
+  module QEMU
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def initialize(machine)
+        @machine = machine
+
+        # TODO support NFS
+        @machine.config.nfs.functional = false
+
+        # This method will load in our driver, so we call it now to
+        # initialize it.
+        machine_id_changed
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def machine_id_changed
+        @driver = Driver.new(@machine.id, @machine.data_dir)
+      end
+
+      def ssh_info
+        # If the VM is not running that we can't possibly SSH into it
+        return nil if state.id != :running
+
+        return {
+          host: "127.0.0.1",
+          port: @machine.provider_config.ssh_port
+        }
+      end
+
+      def state
+        state_id = nil
+        state_id = :not_created if !@machine.id
+
+        if !state_id
+          # Run a custom action we define called "read_state" which does
+          # what it says. It puts the state in the `:machine_state_id`
+          # key in the environment.
+          env = @machine.action(:read_state)
+          state_id = env[:machine_state_id]
+        end
+
+        # Get the short and long description
+        short = state_id.to_s
+        long  = ""
+
+        # If we're not created, then specify the special ID flag
+        if state_id == :not_created
+          state_id = Vagrant::MachineState::NOT_CREATED_ID
+        end
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "QEMU (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/util/timer.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module QEMU
+    module Util
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module QEMU
+    VERSION = '0.1.2'
+  end
+end

data/lib/vagrant-qemu.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant-qemu/plugin"
+
+module VagrantPlugins
+  module QEMU
+    lib_path = Pathname.new(File.expand_path("../vagrant-qemu", __FILE__))
+    autoload :Action, lib_path.join("action")
+    autoload :Errors, lib_path.join("errors")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/locales/en.yml

@@ -0,0 +1,54 @@
+en:
+  vagrant_qemu:
+    already_status: |-
+      The machine is already %{status}.
+    not_created: |-
+      Instance is not created. Please run `vagrant up` first.
+    rsync_not_found_warning: |-
+      Warning! Folder sync disabled because the rsync binary is missing in the %{side}.
+      Make sure rsync is installed and the binary can be found in the PATH.
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    starting: |-
+      Starting the instance...
+    stopping: |-
+      Stopping the instance...
+    destroying: |-
+      Destroying the instance...
+    warn_networks: |-
+      Warning! The QEMU provider doesn't support any of the Vagrant
+      high-level network configurations (`config.vm.network`). They
+      will be silently ignored.
+    will_not_destroy: |-
+      The instance '%{name}' will not be destroyed, since the confirmation
+      was declined.
+
+    errors:
+      not_supported: |-
+        Function not supported.
+      rsync_error: |-
+        There was an error when attempting to rsync a shared folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+      mkdir_error: |-
+        There was an error when attempting to create a shared host folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Error: %{err}
+      box_invalid: |-
+        The box you're using with the QEMU provider ('%{name}')
+        is invalid.
+      execute_error: |-
+        A command executed by Vagrant didn't complete successfully!
+        The command run along with the output from the command is shown
+        below.
+
+        Command: %{command}
+
+        Stderr: %{stderr}
+
+        Stdout: %{stdout}

data/vagrant-qemu.gemspec

@@ -0,0 +1,52 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "vagrant-qemu/version"
+
+Gem::Specification.new do |s|
+  s.name          = "vagrant-qemu"
+  s.version       = VagrantPlugins::QEMU::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.license       = "MIT"
+  s.authors       = "ppggff"
+  s.email         = "pgf00a@gmail.com.com"
+  s.homepage      = ""
+  s.summary       = "Enables Vagrant to manage machines with QEMU."
+  s.description   = "Enables Vagrant to manage machines with QEMU."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "vagrant-qemu"
+
+  # The following block of code determines the files that should be included
+  # in the gem. It does this by reading all the files in the directory where
+  # this gemspec is, and parsing out the ignored files from the gitignore.
+  # Note that the entire gitignore(5) syntax is not supported, specifically
+  # the "!" syntax, but it should mostly work correctly.
+  root_path      = File.dirname(__FILE__)
+  all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+  all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+  gitignore_path = File.join(root_path, ".gitignore")
+  gitignore      = File.readlines(gitignore_path)
+  gitignore.map!    { |line| line.chomp.strip }
+  gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+
+  unignored_files = all_files.reject do |file|
+    # Ignore any directories, the gemspec only cares about files
+    next true if File.directory?(file)
+
+    # Ignore any paths that match anything in the gitignore. We do
+    # two tests here:
+    #
+    #   - First, test to see if the entire path matches the gitignore.
+    #   - Second, match if the basename does, this makes it so that things
+    #     like '.DS_Store' will match sub-directories too (same behavior
+    #     as git).
+    #
+    gitignore.any? do |ignore|
+      File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+        File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+    end
+  end
+
+  s.files         = unignored_files
+  s.executables   = unignored_files.map { |f| f[/^bin\/(.*)/, 1] }.compact
+  s.require_path  = 'lib'
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-qemu
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- ppggff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-01-06 00:00:00.000000000 Z
+dependencies: []
+description: Enables Vagrant to manage machines with QEMU.
+email: pgf00a@gmail.com.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/vagrant-qemu.rb
+- lib/vagrant-qemu/action.rb
+- lib/vagrant-qemu/action/destroy.rb
+- lib/vagrant-qemu/action/import.rb
+- lib/vagrant-qemu/action/message_already_created.rb
+- lib/vagrant-qemu/action/message_not_created.rb
+- lib/vagrant-qemu/action/message_will_not_destroy.rb
+- lib/vagrant-qemu/action/read_state.rb
+- lib/vagrant-qemu/action/start_instance.rb
+- lib/vagrant-qemu/action/stop_instance.rb
+- lib/vagrant-qemu/action/warn_networks.rb
+- lib/vagrant-qemu/config.rb
+- lib/vagrant-qemu/driver.rb
+- lib/vagrant-qemu/errors.rb
+- lib/vagrant-qemu/plugin.rb
+- lib/vagrant-qemu/provider.rb
+- lib/vagrant-qemu/util/timer.rb
+- lib/vagrant-qemu/version.rb
+- locales/en.yml
+- vagrant-qemu.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Enables Vagrant to manage machines with QEMU.
+test_files: []