vagrant-xapi 0.0.1 → 1.0.0

data/lib/vagrant-xapi/action/cloud_init.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "tmpdir"
+require "yaml"
+require "vagrant/action/builtin/cloud_init_setup"
+
+require_relative "../errors"
+require_relative "../glue"
+
+module VagrantPlugins
+  module Xapi
+    module Action
+      # The built-in CloudInitSetup plus a `network-config` for a static IP on
+      # VIF device 0 (XAPI has no DHCP). Also builds the NoCloud ISO when there
+      # is only network config and no user-data, so boxes without a guest
+      # agent (e.g. libvirt boxes) still get their address.
+      #
+      # The ISO is attached by configure_disks as a :dvd disk named
+      # "vagrant-cloud_init-disk"; when its content changes, the VDI is
+      # replaced.
+      class CloudInitSetup < Vagrant::Action::Builtin::CloudInitSetup
+        ISO_SENTINEL = "xapi_cloud_init_iso"
+
+        def call(env)
+          catch(:complete) do
+            machine = env[:machine]
+            sentinel_path = machine.data_dir.join("action_cloud_init")
+            if sentinel_path.file?
+              if sentinel_path.read.chomp == machine.id.to_s
+                throw :complete if machine.config.vm.cloud_init_first_boot_only
+              end
+              sentinel_path.unlink
+            end
+
+            user_data_configs = machine.config.vm.cloud_init_configs.select { |c| c.type == :user_data }
+            network_config = Errors.wrap { build_network_config(env) }
+            throw :complete if user_data_configs.empty? && network_config.nil?
+
+            user_data = if user_data_configs.empty?
+                          "#cloud-config\n{}\n"
+                        else
+                          setup_user_data(machine, env, user_data_configs).to_s
+                        end
+            meta_data = { "instance-id" => "i-#{machine.id.split("-").join}" }
+            iso = write_iso(machine, env, user_data, meta_data, network_config)
+            attach_disk_config(machine, env, iso)
+          end
+
+          @app.call(env)
+        end
+
+        # cloud-init network-config v2, matched on MAC.
+        # @return [Hash, nil]
+        def build_network_config(env)
+          machine = env[:machine]
+          plan = Glue.vif_plan(machine)
+          first = plan.first
+          return nil unless first&.static_ip? && first.auto_config
+
+          client = env[:xapi] || Glue.client(machine)
+          ref = client.call("VM.get_by_uuid", machine.id)
+          macs = client.call("VM.get_VIFs", ref).to_h do |vif|
+            rec = client.call("VIF.get_record", vif)
+            [rec["device"].to_i, rec["MAC"].to_s.downcase]
+          end
+
+          ethernets = {}
+          plan.each do |spec|
+            mac = macs[spec.device]
+            next if mac.nil? || mac.empty?
+
+            name = "vif#{spec.device}"
+            if spec.device.zero?
+              entry = { "match" => { "macaddress" => mac }, "dhcp4" => false,
+                        "addresses" => ["#{spec.ip}/#{spec.prefix_length}"] }
+              entry["routes"] = [{ "to" => "default", "via" => spec.gateway.to_s }] if spec.gateway
+              dns = Glue.networks(machine).find { |t, _| t == :public_network }&.last&.dig(:nameservers)
+              entry["nameservers"] = { "addresses" => Array(dns).map(&:to_s) } if dns
+              ethernets[name] = entry
+            elsif !spec.static_ip? && spec.kind != :internal
+              # cloud-init's fallback DHCP is off once network-config exists.
+              ethernets[name] = { "match" => { "macaddress" => mac }, "dhcp4" => true, "optional" => true }
+            end
+          end
+          { "version" => 2, "ethernets" => ethernets }
+        end
+
+        private
+
+        def write_iso(machine, env, user_data, meta_data, network_config)
+          raise Vagrant::Errors::CreateIsoHostCapNotFound unless env[:env].host.capability?(:create_iso)
+
+          files = { "user-data" => user_data, "meta-data" => meta_data.to_yaml }
+          files["network-config"] = network_config.to_yaml if network_config
+          checksum = Digest::SHA256.hexdigest(files.sort.map { |k, v| "#{k}\0#{v}" }.join("\0"))
+
+          sentinel = machine.data_dir.join(ISO_SENTINEL)
+          if sentinel.file?
+            sum, path = sentinel.read.chomp.split(":", 2)
+            return Pathname.new(path) if sum == checksum && File.file?(path.to_s)
+
+            FileUtils.rm_f(path.to_s) if path.to_s.include?("vagrant-xapi-cidata")
+          end
+
+          source_dir = Pathname.new(Dir.mktmpdir(TEMP_PREFIX))
+          begin
+            files.each { |name, content| File.write(source_dir.join(name), content) }
+            dest = machine.data_dir.join("vagrant-xapi-cidata-#{checksum[0, 12]}.iso")
+            path = env[:env].host.capability(:create_iso, source_dir, volume_id: "cidata",
+                                                                      file_destination: dest.to_s)
+            sentinel.write("#{checksum}:#{path}")
+            Pathname.new(path.to_s)
+          ensure
+            FileUtils.remove_entry(source_dir)
+          end
+        end
+
+        def attach_disk_config(machine, _env, iso_path)
+          path = iso_path.to_s
+          return if machine.config.vm.disks.any? { |d| d.type == :dvd && d.file == path }
+
+          machine.config.vm.disk(:dvd, file: path, name: "vagrant-cloud_init-disk")
+          machine.config.vm.disks.each { |d| d.finalize! if d.type == :dvd && d.file == path }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/action/create.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+require_relative "base"
+require_relative "../services/box_source"
+require_relative "../services/template_cache"
+require_relative "../services/vm_builder"
+require_relative "../services/networks"
+require_relative "../services/destroyer"
+require_relative "../services/lookup"
+require_relative "../services/disks"
+
+module VagrantPlugins
+  module Xapi
+    module Action
+      # Makes sure the box exists as a template on template_sr
+      # (env[:xapi_template]).
+      class ImportTemplate < Base
+        def call(env)
+          machine = env[:machine]
+          box = machine.box
+          raise Vagrant::Errors::BoxNotFound, name: machine.config.vm.box.to_s if box.nil?
+
+          wrap do
+            c = ctx(env)
+            cfg = config(env)
+            source = Services::BoxSource.new(
+              name: box.name, version: box.version, provider: box.provider,
+              directory: box.directory, xva_url: cfg.xva_url || legacy_xva_url(machine, box)
+            )
+            warn_architecture(env, source)
+            sr = Services::Lookup.new(c).sr(cfg.template_sr || cfg.sr)
+            cache = Services::TemplateCache.new(
+              c,
+              digest_cache: Services::DigestCache.new(digest_path(machine)),
+              # Testing aid: forces a fresh template for the same box content.
+              salt: ENV["VAGRANT_XAPI_TEMPLATE_SALT"],
+              converter: Glue.method(:convert_qcow2),
+              # Longer than the lock's TTL, so a lock of a crashed process
+              # expires while we still wait and can be taken over.
+              lock_wait: (2 * cfg.task_timeout) + 1500,
+              task_timeout: cfg.task_timeout
+            )
+            env[:xapi_template] = cache.ensure_template(source, sr)
+          end
+          @app.call(env)
+        end
+
+        private
+
+        def digest_path(machine)
+          Glue.data_home(machine.env).join("digests.json")
+        end
+
+        # Boxes of vagrant-xenserver may only contain a Vagrantfile with
+        # `xs.xva_url = "..."` in a :xenserver provider block.
+        def legacy_xva_url(machine, box)
+          url = begin
+            cfg = machine.config.vm.get_provider_config(:xenserver)
+            cfg.instance_variable_get(:@xva_url)
+          rescue StandardError
+            nil
+          end
+          return url if url.is_a?(String) && !url.empty?
+
+          vagrantfile = box.directory.join("Vagrantfile")
+          return nil unless vagrantfile.file?
+
+          vagrantfile.read[/xva_url\s*=\s*["']([^"']+)["']/, 1]
+        end
+
+        def warn_architecture(env, source)
+          arch = source.architecture
+          return if arch.nil? || %w[amd64 x86_64].include?(arch.to_s)
+
+          env[:ui].warn(I18n.t("vagrant_xapi.messages.box_architecture", arch: arch))
+        end
+      end
+
+      # Clones (or copies) the template into a new VM, applies the config and
+      # creates the VIFs. All or nothing: a failure removes the VM again.
+      class CreateVm < Base
+        def call(env)
+          machine = env[:machine]
+          wrap do
+            c = ctx(env)
+            cfg = config(env)
+            lookup = Services::Lookup.new(c)
+            sr = cfg.clone_mode == :full ? lookup.sr(cfg.sr) : nil
+            vm = Services::VmBuilder.new(c).create(env[:xapi_template], Glue.vm_spec(machine),
+                                                   clone_mode: cfg.clone_mode, sr_ref: sr)
+            networks = Services::Networks.new(c, project: Glue.project_path(machine))
+            begin
+              networks.apply(vm, Glue.vif_plan(machine))
+              Services::Disks.new(c).sync_isos(vm, cfg.isos)
+            rescue Exception # rubocop:disable Lint/RescueException
+              used = Services::Destroyer.new(c).destroy(vm, require_marking: false)
+              networks.cleanup_unused(used)
+              raise
+            end
+            machine.id = c.client.call("VM.get_uuid", vm)
+          end
+          @app.call(env)
+        end
+      end
+
+      # Re-applies CPU, memory, firmware, platform and VIFs to a halted VM
+      # (reload).
+      class ConfigureVm < Base
+        def call(env)
+          machine = env[:machine]
+          wrap do
+            c = ctx(env)
+            ref = vm(env)
+            env[:ui].info(I18n.t("vagrant_xapi.messages.applying_config"))
+            Services::VmBuilder.new(c).apply(ref, Glue.vm_spec(machine))
+            Services::Networks.new(c, project: Glue.project_path(machine)).apply(ref, Glue.vif_plan(machine))
+            Services::Disks.new(c).sync_isos(ref, config(env).isos)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require_relative "base"
+require_relative "network"
+require_relative "../services/destroyer"
+require_relative "../services/networks"
+
+module VagrantPlugins
+  module Xapi
+    module Action
+      # Refuses to go on unless the VM is marked for this machine and project.
+      # Runs before anything halts or changes the VM.
+      class CheckOwner < Base
+        def call(env)
+          machine = env[:machine]
+          wrap do
+            ref = Glue.vm_ref(machine, ctx(env))
+            if ref
+              Services::Destroyer.new(ctx(env)).check_owner!(
+                ref, { machine: machine.name, project: Glue.project_path(machine) }
+              )
+            end
+          end
+          @app.call(env)
+        end
+      end
+
+      # Removes the VM, its snapshots, its own VDIs (never template VDIs),
+      # unused internal networks of the project, and our files in data_dir.
+      class DestroyVm < Base
+        OWN_FILES = %w[forwarded_ports.json tunnels.log disk_meta action_cloud_init
+                       action_cloud_init_iso xapi_cloud_init_iso].freeze
+
+        def call(env)
+          machine = env[:machine]
+          Action.tunnels(machine).stop
+          wrap do
+            c = ctx(env)
+            ref = Glue.vm_ref(machine, c)
+            if ref
+              Extensions.before_destroy(machine, c, ref)
+              used = Services::Destroyer.new(c).destroy(
+                ref, owner: { machine: machine.name, project: Glue.project_path(machine) }
+              )
+              Services::Networks.new(c, project: Glue.project_path(machine)).cleanup_unused(used)
+            end
+          end
+          cleanup_files(machine)
+          machine.id = nil
+          @app.call(env)
+        end
+
+        private
+
+        def cleanup_files(machine)
+          iso_sentinel = machine.data_dir.join("xapi_cloud_init_iso")
+          if iso_sentinel.file?
+            path = iso_sentinel.read.split(":", 2).last.to_s
+            FileUtils.rm_f(path) if path.include?("vagrant-xapi-cidata")
+          end
+          OWN_FILES.each { |f| FileUtils.rm_f(machine.data_dir.join(f)) }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/action/network.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "socket"
+require "vagrant/action/builtin/mixin_synced_folders"
+require "vagrant/util/is_port_open"
+
+require_relative "base"
+require_relative "../services/tunnels"
+require_relative "../services/inventory"
+
+module VagrantPlugins
+  module Xapi
+    module Action
+      def self.tunnels(machine)
+        Services::Tunnels.new(machine.data_dir, logger: Glue::LOGGER)
+      end
+
+      # Starts one SSH tunnel per forwarded_port (after WaitForCommunicator).
+      class StartTunnels < Base
+        def call(env)
+          machine = env[:machine]
+          forwards = Glue.forwarded_ports(machine)
+          unless forwards.empty?
+            info = machine.ssh_info
+            raise Vagrant::Errors::SSHNotReady if info.nil?
+
+            announce(env, forwards)
+            wrap { Action.tunnels(machine).start(forwards, ssh_options(info)) }
+          end
+          @app.call(env)
+        end
+
+        private
+
+        def announce(env, forwards)
+          env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.forwarding"))
+          forwards.each do |f|
+            env[:ui].detail(I18n.t("vagrant_xapi.messages.forwarding_port",
+                                   host_ip: f.host_ip, host: f.host, guest: f.guest))
+          end
+        end
+
+        def ssh_options(info)
+          {
+            host: info[:host], port: info[:port], username: info[:username],
+            private_key_path: info[:private_key_path], proxy_command: info[:proxy_command]
+          }
+        end
+      end
+
+      # On `vagrant up` of a running (or paused) VM: bring the tunnels in line
+      # with the Vagrantfile. Tunnels that died (e.g. after the local machine
+      # rebooted) or whose forward changed are restarted, tunnels of removed
+      # forwards are stopped, and the others are left alone. A forward with
+      # auto_correct whose host port is unchanged keeps the port it was
+      # auto-corrected to at boot.
+      #
+      # Vagrant's collision check only runs at boot, so new host ports are
+      # checked here, before any tunnel is stopped: a taken port moves to a
+      # free one with auto_correct, and is Vagrant's collision error without.
+      class EnsureTunnels < StartTunnels
+        def call(env)
+          machine = env[:machine]
+          tunnels = Action.tunnels(machine)
+          plan = tunnels.plan(tunnels.with_saved_ports(Glue.forwarded_ports(machine)))
+          return @app.call(env) if plan.noop?
+
+          info = machine.ssh_info
+          if info.nil? && !plan.start.empty?
+            # No IP yet (e.g. the guest agent has not reported): stop what
+            # must go, which needs no SSH, but do not fail `vagrant up` of a
+            # running VM over the tunnels that cannot start yet.
+            wrap { tunnels.sync(Services::Tunnels::Plan.new(keep: plan.keep, stop: plan.stop, start: []), {}) }
+            env[:ui].warn(I18n.t("vagrant_xapi.messages.tunnels_need_ip"))
+            return @app.call(env)
+          end
+
+          plan.start = free_ports(env, plan)
+          announce(env, plan.start) unless plan.start.empty?
+          wrap { tunnels.sync(plan, info ? ssh_options(info) : {}) }
+          @app.call(env)
+        end
+
+        private
+
+        def free_ports(env, plan)
+          machine = env[:machine]
+          checker = env[:port_collision_port_check] || ->(ip, port) { port_taken?(machine, ip, port) }
+          # Ports of tunnels about to be stopped are ours, so free.
+          ours = plan.stop.map { |t| t["host"].to_i }
+          used = plan.keep.map { |t| t["host"].to_i } + plan.start.map(&:host)
+          plan.start.map do |fwd|
+            next fwd if ours.include?(fwd.host) || !checker.call(fwd.host_ip, fwd.host)
+
+            unless fwd.auto_correct
+              raise Vagrant::Errors::ForwardPortCollision, guest_port: fwd.guest.to_s, host_port: fwd.host.to_s
+            end
+
+            port = machine.config.vm.usable_port_range.find do |p|
+              !used.include?(p) && (ours.include?(p) || !checker.call(fwd.host_ip, p))
+            end
+            unless port
+              raise Vagrant::Errors::ForwardPortAutolistEmpty,
+                    vm_name: machine.name, guest_port: fwd.guest.to_s, host_port: fwd.host.to_s
+            end
+
+            used << port
+            env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
+                                 host_port: fwd.host.to_s, guest_port: fwd.guest.to_s, new_port: port.to_s))
+            fwd.dup.tap { |f| f.host = port }
+          end
+        end
+
+        # The same check Vagrant's HandleForwardedPortCollisions does.
+        def port_taken?(machine, host_ip, port)
+          collisions = Vagrant::Action::Builtin::HandleForwardedPortCollisions
+          return collisions.port_check(machine, host_ip, port) if collisions.respond_to?(:port_check)
+
+          Vagrant::Util::IsPortOpen.is_port_open?(host_ip, port)
+        end
+      end
+
+      class StopTunnels < Base
+        def call(env)
+          Action.tunnels(env[:machine]).stop
+          @app.call(env)
+        end
+      end
+
+      # Prepares HandleForwardedPortCollisions at boot and resume. Runs after
+      # StopTunnels, so no port is held by a tunnel of this machine.
+      # Remembers each forward's host port from the Vagrantfile, because
+      # collision repair overwrites options[:host].
+      #
+      # Vagrant's default SSH forward (id "ssh", 22 => 2222) gets no tunnel
+      # unless forward_ssh_port is set, so it is marked disabled: it must not
+      # collide with anything on the local machine (that made `resume` fail
+      # when port 2222 was taken), and `vagrant port` should not show it.
+      class PrepareForwardedPortCollisionParams < Base
+        def call(env)
+          machine = env[:machine]
+          env[:port_collision_extra_in_use] = {}
+          machine.config.vm.networks.each do |type, options|
+            next unless type == :forwarded_port
+
+            options[:disabled] = true if options[:id].to_s == "ssh" && !machine.provider_config.forward_ssh_port
+            options[Glue::CONFIGURED_HOST] ||= options[:host]
+          end
+          @app.call(env)
+        end
+      end
+
+      # NFS exports of machines not in this list are pruned, so it must hold
+      # every live machine of this installation: VMs marked with our client
+      # id on this pool, plus the VM UUIDs of all xapi machines Vagrant knows
+      # (other pools, older markings).
+      #
+      # Building it reads every VM record of the pool, and only NFS uses it,
+      # so it is built only for a machine with NFS folders, now or at its
+      # last boot (Vagrant's cache). Without the list, Vagrant's NFS cleanup
+      # hook prunes nothing, as for any provider that gives none.
+      class PrepareNFSValidIds < Base
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+
+        def call(env)
+          machine = env[:machine]
+          env[:nfs_valid_ids] = valid_ids(env, machine) if nfs?(machine)
+          @app.call(env)
+        end
+
+        private
+
+        def nfs?(machine)
+          synced_folders(machine).key?(:nfs) || synced_folders(machine, cached: true).key?(:nfs)
+        end
+
+        def valid_ids(env, machine)
+          ids = wrap do
+            Services::Inventory.new(ctx(env)).my_vms(client_id: Glue.client_id(machine.env)).map(&:uuid)
+          end
+          ids |= Glue.indexed_vm_ids(machine.env)
+          ids |= [machine.id] if machine.id
+          ids
+        end
+      end
+
+      # NFS: the host IP is the source address of the route to the guest,
+      # found with a UDP socket in Ruby (no `ip route` or `route get`).
+      class PrepareNFSSettings < Base
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+
+        def call(env)
+          @app.call(env)
+
+          machine = env[:machine]
+          opts = {
+            cached: !!env[:synced_folders_cached],
+            config: env[:synced_folders_config],
+            disable_usable_check: !!env[:test]
+          }
+          folders = synced_folders(machine, **opts)
+          return unless folders.key?(:nfs)
+
+          info = machine.ssh_info
+          raise Vagrant::Errors::NFSNoGuestIP if info.nil? || info[:host].to_s.empty?
+
+          guest_ip = info[:host].to_s
+          env[:nfs_machine_ip] = guest_ip
+          env[:nfs_host_ip] = self.class.source_address_for(guest_ip)
+          raise Vagrant::Errors::NFSNoHostonlyNetwork if env[:nfs_host_ip].nil?
+        end
+
+        def self.source_address_for(ip)
+          family = ip.include?(":") ? Socket::AF_INET6 : Socket::AF_INET
+          sock = UDPSocket.new(family)
+          begin
+            # UDP connect sends nothing; it only selects a route.
+            sock.connect(ip, 9)
+            sock.local_address.ip_address
+          ensure
+            sock.close
+          end
+        rescue SystemCallError, SocketError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/action/package.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "vagrant/action/general/package"
+require "vagrant/action/general/package_setup_files"
+require "vagrant/action/general/package_setup_folders"
+require "vagrant/util/safe_chdir"
+require "vagrant/util/subprocess"
+
+require_relative "base"
+require_relative "../services/diff_disks"
+require_relative "../services/exporter"
+
+module VagrantPlugins
+  module Xapi
+    module Action
+      class PackageSetupFolders < Vagrant::Action::General::PackageSetupFolders; end
+      class PackageSetupFiles < Vagrant::Action::General::PackageSetupFiles; end
+
+      # Vagrant's compress ignores the exit status of bsdtar, so a failure
+      # (e.g. a full disk) left a truncated box behind without an error, and
+      # only `vagrant box add` noticed. Same command, with the check.
+      class Package < Vagrant::Action::General::Package
+        def compress
+          output_path = fullpath.to_s
+          Vagrant::Util::SafeChdir.safe_chdir(@env["package.directory"]) do
+            files = Dir.glob(File.join(".", "*"))
+            result = Vagrant::Util::Subprocess.execute("bsdtar", "-czf", output_path, *files)
+            unless result.exit_code.zero?
+              FileUtils.rm_f(output_path)
+              raise Errors::ServiceFailed.new(:package_compress_failed, path: output_path,
+                                                                        detail: result.stderr.to_s.strip)
+            end
+          end
+        end
+      end
+
+      # Exports the halted VM into env["export.temp_dir"] as box.<format> plus
+      # metadata.json (provider "xapi", format, architecture "amd64").
+      class PackageExport < Base
+        def call(env)
+          machine = env[:machine]
+          if machine.state.id != :halted
+            raise Errors::ServiceFailed.new(:package_needs_halt, {})
+          end
+
+          wrap do
+            disks = Services::DiffDisks.new(ctx(env))
+            # A box must not take along the disks of an interrupted diff; one
+            # that cannot be removed stops the export. Under the diff lock of
+            # the VM, export included: a diff still running on it keeps its
+            # disks, and none is attached while the box is made.
+            disks.synchronize(vm(env), wait: Services::DiffDisks::LEFTOVER_LOCK_WAIT) do
+              disks.cleanup_leftovers(vm(env), unattached: false, required: true)
+              env[:xapi_package_metadata] = Services::Exporter.new(ctx(env)).export(
+                vm(env), env["export.temp_dir"], format: config(env).package_format
+              )
+            end
+          end
+          @app.call(env)
+        end
+      end
+
+      # Vagrantfile in the box with firmware, cpus and memory as provider
+      # defaults. --vagrantfile and --include are handled by Vagrant core.
+      class PackageVagrantfile < Base
+        def call(env)
+          values = wrap do
+            client = ctx(env).client
+            rec = client.call("VM.get_record", vm(env))
+            {
+              firmware: (rec["HVM_boot_params"] || {})["firmware"] || "bios",
+              cpus: rec["VCPUs_max"].to_i,
+              memory: rec["memory_static_max"].to_i / (1024 * 1024)
+            }
+          end
+          File.write(File.join(env["export.temp_dir"], "Vagrantfile"), render(values))
+          @app.call(env)
+        end
+
+        def render(values)
+          <<~RUBY
+            # Generated by vagrant-xapi #{VERSION} (vagrant package).
+            Vagrant.configure("2") do |config|
+              config.vm.box_architecture = "amd64"
+              config.vm.allowed_synced_folder_types = [:rsync, :nfs, :smb]
+              config.vm.provider :xapi do |xapi|
+                xapi.firmware = :#{values[:firmware] == "uefi" ? "uefi" : "bios"}
+                xapi.cpus = #{values[:cpus].to_i}
+                xapi.memory = #{values[:memory].to_i}
+              end
+            end
+
+            # Load the Vagrantfile given with `vagrant package --vagrantfile`
+            # after these defaults, so it can override them.
+            include_vagrantfile = File.expand_path("../include/_Vagrantfile", __FILE__)
+            load include_vagrantfile if File.exist?(include_vagrantfile)
+          RUBY
+        end
+      end
+    end
+  end
+end