vagrant-xapi 0.0.1 → 1.0.0

data/lib/vagrant-xapi/command/diff.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "json"
+require "tmpdir"
+
+require_relative "base"
+require_relative "../services/differ"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi diff [vm] (--from SNAPSHOT [--to SNAPSHOT] | --with MACHINE)
+      #
+      # Which files differ between a snapshot and the running guest, two
+      # snapshots, or two running machines. Snapshots are made with
+      # `vagrant snapshot save`; the names are those of `vagrant snapshot list`.
+      class Diff < Base
+        LETTERS = { added: "A", removed: "D", changed: "M", metadata: "m", type: "T" }.freeze
+
+        # For --plain and --json: stdout carries only the result. Warnings go
+        # to stderr, progress is dropped.
+        class StderrUi
+          def initialize(ui)
+            @ui = ui
+          end
+
+          def info(*); end
+
+          def detail(*); end
+
+          def clear_line; end
+
+          def warn(message, *_opts)
+            @ui.warn(message, channel: :error)
+          end
+        end
+
+        def execute
+          options = { paths: [], excludes: [], checksum: false, default_excludes: true, style: :table }
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant xapi diff [vm-name] (--from SNAPSHOT [--to SNAPSHOT] | --with MACHINE) [options]"
+            o.separator ""
+            o.separator "Lists the files that were added, removed or changed. The machine must be running."
+            o.separator ""
+            o.on("--from SNAPSHOT", "Compare this snapshot with the running machine (or with --to)") do |v|
+              options[:from] = v
+            end
+            o.on("--to SNAPSHOT", "Compare with this snapshot instead of the running machine") { |v| options[:to] = v }
+            o.on("--with MACHINE", "Compare with another running machine of this Vagrantfile") do |v|
+              options[:with] = v
+            end
+            o.on("--path DIR", "Only paths below DIR (repeatable)") { |v| options[:paths] << v }
+            o.on("--exclude PATTERN",
+                 "Leave out paths matching this glob, and what is below them; without a leading / at any depth " \
+                 "(repeatable)") do |v|
+              options[:excludes] << v
+            end
+            o.on("--no-default-excludes",
+                 "Also compare #{Services::FileDiff::DEFAULT_EXCLUDES.join(", ")}") do
+              options[:default_excludes] = false
+            end
+            o.on("--checksum", "Compare the content of every file, not only of files whose time changed") do
+              options[:checksum] = true
+            end
+            o.on("--content", "Also show what changed in each file (unified diff; not with --plain)") do
+              options[:content] = true
+            end
+            o.on("--content-limit SIZE", "With --content: largest file to show (default 1M; K and M suffixes)") do |v|
+              options[:content_limit] = Services::ContentDiff.parse_size(v) || :invalid
+            end
+            o.on("--plain", "One change per line, tab-separated (for scripts)") { options[:style] = :plain }
+            o.on("--json", "JSON") { options[:style] = :json }
+          end
+          argv = parse_options(opts)
+          return 0 if argv.nil?
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp unless valid?(argv, options)
+
+          each_xapi_machine(argv, single: true) do |machine|
+            print_result(machine, run(machine, options), options[:style])
+          end
+          0
+        end
+
+        private
+
+        def valid?(argv, options)
+          return false if argv.size > 1
+          return false unless options[:paths].all? { |p| p.start_with?("/") }
+          # --plain is one change per line; a diff would break that.
+          return false if options[:content] && options[:style] == :plain
+          return false if options[:content_limit] && (!options[:content] || options[:content_limit] == :invalid)
+
+          if options[:with]
+            options[:from].nil? && options[:to].nil?
+          else
+            !options[:from].nil?
+          end
+        end
+
+        def run(machine, options)
+          check_running!(machine)
+          other = options[:with] && other_machine(machine, options[:with])
+          excludes = (options[:default_excludes] ? Services::FileDiff::DEFAULT_EXCLUDES : []) + options[:excludes]
+          filter = Services::FileDiff::Filter.new(paths: options[:paths], excludes: excludes)
+          ui = options[:style] == :table ? nil : StderrUi.new(machine.ui)
+          content = options[:content] ? (options[:content_limit] || Services::ContentDiff::DEFAULT_LIMIT) : nil
+          @content_limit = content
+          interruptible do |stopped|
+            ctx = Glue.context(machine, cancel: stopped, ui: ui)
+            Dir.mktmpdir("vagrant-xapi-diff-") do |tmp|
+              differ = Services::Differ.new(ctx, tmpdir: tmp)
+              if other
+                # The other machine may be on another pool: its own context.
+                other_ctx = Glue.context(other, cancel: stopped, ui: ui)
+                differ.machines(Glue::GuestShell.new(machine), Glue::GuestShell.new(other),
+                                vms: [[ctx, Glue.vm_ref(machine, ctx)], [other_ctx, Glue.vm_ref(other, other_ctx)]],
+                                names: [machine.name.to_s, other.name.to_s], filter: filter,
+                                checksum: options[:checksum], content: content)
+              else
+                differ.snapshot(Glue.vm_ref(machine, ctx), Glue::GuestShell.new(machine),
+                                from: options[:from], to: options[:to], filter: filter,
+                                checksum: options[:checksum], content: content)
+              end
+            end
+          end
+        end
+
+        # The files are read through the guest, so it must be running and
+        # reachable.
+        def check_running!(machine)
+          raise Vagrant::Errors::VMNotCreatedError unless machine.id
+          unless machine.state.id == :running
+            raise Errors::ServiceFailed.new(:diff_needs_running, machine: machine.name.to_s)
+          end
+          return if machine.communicate.ready?
+
+          raise Errors::ServiceFailed.new(:diff_guest_unreachable, machine: machine.name.to_s)
+        end
+
+        def other_machine(machine, name)
+          other = nil
+          with_target_vms([name], single_target: true) { |m| other = m }
+          raise Errors::ServiceFailed.new(:diff_same_machine, machine: name.to_s) if other.name == machine.name
+          unless Extensions.provider?(other.provider_name)
+            raise Errors::ServiceFailed.new(:diff_other_provider, machine: other.name.to_s,
+                                                                  provider: other.provider_name.to_s)
+          end
+
+          check_running!(other)
+          other
+        end
+
+        def print_result(machine, result, style)
+          changes = result.changes
+          case style
+          when :json
+            json = { "compared" => result.mountpoints.map { |m| escape(m) },
+                     "read_errors" => result.read_errors,
+                     "changes" => changes.map { |c| as_json(c).merge(content_json(result, c)) } }
+            @env.ui.info(JSON.pretty_generate(json), prefix: false)
+          when :plain
+            return if changes.empty?
+
+            @env.ui.info(changes.map { |c| [LETTERS[c.kind], escape(c.path), detail(c)].join("\t") }.join("\n"),
+                         prefix: false)
+          else
+            machine.ui.info(t("diff_compared", mountpoints: result.mountpoints.map { |m| escape(m) }.join(", ")))
+            if changes.empty?
+              machine.ui.info(t("diff_no_changes"))
+              return
+            end
+            lines = changes.map do |c|
+              d = detail(c)
+              "#{LETTERS[c.kind]} #{escape(c.path)}#{d.empty? ? "" : "  (#{d})"}"
+            end
+            @env.ui.info(lines.join("\n"), prefix: false)
+            counts = LETTERS.keys.to_h { |kind| [kind, changes.count { |c| c.kind == kind }] }
+            machine.ui.info(t("diff_summary", **counts))
+            print_contents(result) if result.contents
+          end
+        end
+
+        # The diffs of --content, in the order of the list. They are escaped
+        # already (ContentDiff); a skipped file gets one line why.
+        def print_contents(result)
+          blocks = result.changes.filter_map do |change|
+            content = result.contents[change.path]
+            next unless content
+
+            content[:diff] || t("diff_content_#{content[:skipped]}",
+                                path: escape(change.path), size: content[:size].to_s, limit: @content_limit.to_s,
+                                budget: human_size(Services::ContentDiff.budget(@content_limit)))
+          end
+          @env.ui.info("\n#{blocks.join("\n")}", prefix: false) unless blocks.empty?
+        end
+
+        def content_json(result, change)
+          content = result.contents && result.contents[change.path]
+          return {} unless content
+          return { "diff" => content[:diff] } if content[:diff]
+
+          json = { "diff_skipped" => content[:skipped].to_s }
+          json["size"] = content[:size] if content[:size]
+          json
+        end
+
+        def detail(change)
+          a = change.from
+          b = change.to
+          case change.kind
+          when :added, :removed
+            entry = a || b
+            entry.type == "f" ? "" : type_name(entry)
+          when :type
+            t("diff_type_change", from: type_name(a), to: type_name(b))
+          else
+            parts = []
+            if change.kind == :changed
+              parts << if a.type == "l"
+                         t("diff_link", from: escape(a.target), to: escape(b.target))
+                       elsif change.unreadable
+                         t("diff_unreadable")
+                       else
+                         t("diff_content")
+                       end
+            end
+            parts << t("diff_mode", from: fd.mode(a), to: fd.mode(b)) if a.mode != b.mode
+            parts << t("diff_owner", from: fd.owner(a), to: fd.owner(b)) if fd.owner(a) != fd.owner(b)
+            parts.join(", ")
+          end
+        end
+
+        def as_json(change)
+          a = change.from
+          b = change.to
+          json = { "change" => change.kind.to_s, "path" => escape(change.path),
+                   "type" => fd::TYPE_NAMES.fetch((b || a).type, "other") }
+          return json if a.nil? || b.nil?
+
+          if change.kind == :type
+            json["type"] = { "from" => fd::TYPE_NAMES.fetch(a.type, "other"),
+                             "to" => fd::TYPE_NAMES.fetch(b.type, "other") }
+            return json
+          end
+          json["content"] = change.kind == :changed
+          json["unreadable"] = true if change.unreadable
+          json["target"] = { "from" => escape(a.target), "to" => escape(b.target) } if a.type == "l" && a.target != b.target
+          json["mode"] = { "from" => fd.mode(a), "to" => fd.mode(b) } if a.mode != b.mode
+          json["owner"] = { "from" => fd.owner(a), "to" => fd.owner(b) } if fd.owner(a) != fd.owner(b)
+          json
+        end
+
+        def type_name(entry)
+          t("diff_types.#{fd::TYPE_NAMES.fetch(entry.type, "other")}")
+        end
+
+        def escape(value)
+          fd.escape(value)
+        end
+
+        def fd
+          Services::FileDiff
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/command/hosts.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "base"
+require_relative "../services/hosts"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi hosts [--plain|--json|--pem]
+      #
+      # The pool's hosts with address, role and the SHA-256 fingerprint of
+      # their TLS certificate, as the master reports them.
+      class Hosts < Base
+        def execute
+          style = :table
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant xapi hosts [--plain|--json|--pem]"
+            o.separator ""
+            o.separator "The pool's hosts as the master reports them. The fingerprints and"
+            o.separator "certificates come through the verified connection to the master."
+            o.separator ""
+            o.on("--plain", "One host per line, tab-separated, no header: name, address, role,",
+                 "enabled, fingerprint (for scripts)") { style = :plain }
+            o.on("--json", "JSON") { style = :json }
+            o.on("--pem", "The hosts' certificates in PEM, e.g. for tls_ca_file") { style = :pem }
+          end
+          argv = parse_options(opts)
+          return 0 if argv.nil?
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp unless argv.empty?
+
+          machine = connection_machine
+          hosts = Errors.wrap { Services::Hosts.new(Glue.context(machine)).list }
+          print_hosts(hosts, style)
+          0
+        end
+
+        private
+
+        def print_hosts(hosts, style)
+          text = case style
+                 when :json then JSON.pretty_generate(hosts.map(&:to_h))
+                 when :pem then hosts.filter_map(&:certificate).map(&:strip).join("\n")
+                 when :plain
+                   hosts.map { |h| [h.name, h.address, h.role, h.enabled, h.fingerprint].join("\t") }.join("\n")
+                 else table(hosts)
+                 end
+          @env.ui.info(text, prefix: false) unless text.empty?
+        end
+
+        def table(hosts)
+          lines = [format("%-20s %-15s %-6s %-7s %s", "NAME", "ADDRESS", "ROLE", "ENABLED", "FINGERPRINT (SHA-256)")]
+          hosts.each do |h|
+            lines << format("%-20s %-15s %-6s %-7s %s", h.name.to_s[0, 20], h.address, h.role,
+                            h.enabled ? "yes" : "no", h.fingerprint || "-")
+          end
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/command/info.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../services/lookup"
+require_relative "../services/snapshots"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi info [vm]
+      class Info < Base
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant xapi info [vm-name]"
+          end
+          argv = parse_options(opts)
+          return 0 if argv.nil?
+
+          each_xapi_machine(argv) do |machine|
+            ctx = Glue.context(machine)
+            vm = Glue.vm_ref(machine, ctx)
+            unless vm
+              machine.ui.info(t("not_created"))
+              next
+            end
+            machine.ui.info(describe(ctx, vm).join("\n"))
+          end
+          0
+        end
+
+        private
+
+        def describe(ctx, vm)
+          c = ctx.client
+          rec = c.call("VM.get_record", vm)
+          oc = rec["other_config"] || {}
+          lines = []
+          lines << "UUID:      #{rec["uuid"]}"
+          lines << "Name:      #{rec["name_label"]}"
+          lines << "State:     #{rec["power_state"]}"
+          host = rec["resident_on"]
+          lines << "Host:      #{c.call("host.get_name_label", host)}" unless null?(host)
+          affinity = rec["affinity"]
+          lines << "Affinity:  #{c.call("host.get_name_label", affinity)}" unless null?(affinity)
+          lines << "CPUs:      #{rec["VCPUs_max"]}"
+          lines << "Memory:    #{rec["memory_static_max"].to_i / 1024 / 1024} MiB"
+          lines << "Firmware:  #{(rec["HVM_boot_params"] || {})["firmware"] || "bios"}"
+          lines << "Template:  #{template_name(c, oc)}"
+
+          lines << "Disks:"
+          vbds = rec["VBDs"].map { |vbd| c.call("VBD.get_record", vbd) }
+          vbds.sort_by { |b| b["userdevice"].to_i }.each do |b|
+            if null?(b["VDI"])
+              lines << "  #{b["userdevice"]}: #{b["type"]} (empty)"
+              next
+            end
+            vdi = c.call("VDI.get_record", b["VDI"])
+            sr = c.call("SR.get_name_label", vdi["SR"])
+            lines << "  #{b["userdevice"]}: #{b["type"]} #{vdi["name_label"]} " \
+                     "#{human_size(vdi["virtual_size"])} on #{sr} (#{vdi["uuid"]})"
+          end
+
+          metrics = rec["guest_metrics"]
+          nets = null?(metrics) ? {} : (c.call("VM_guest_metrics.get_networks", metrics) rescue {}) # rubocop:disable Style/RescueModifier
+          lines << "VIFs:"
+          rec["VIFs"].map { |v| c.call("VIF.get_record", v) }.sort_by { |v| v["device"].to_i }.each do |v|
+            dev = v["device"]
+            ips = nets.select { |k, _| k.start_with?("#{dev}/") }.values.uniq
+            net = c.call("network.get_name_label", v["network"])
+            lines << "  #{dev}: #{v["MAC"]} on #{net}#{ips.empty? ? "" : " #{ips.join(", ")}"}"
+          end
+
+          snaps = Services::Snapshots.new(ctx).list(vm)
+          lines << "Snapshots: #{snaps.empty? ? "(none)" : snaps.join(", ")}"
+          lines
+        end
+
+        def template_name(client, oc)
+          uuid = oc[Services::Marking::TEMPLATE_UUID]
+          return "(unknown)" if uuid.to_s.empty?
+
+          ref = client.call("VM.get_by_uuid", uuid)
+          "#{client.call("VM.get_name_label", ref)} (#{uuid})"
+        rescue Api::XapiError
+          "#{uuid} (removed)"
+        end
+
+        def null?(ref)
+          Services::Helpers.null_ref?(ref)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/command/marked.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+require_relative "base"
+require_relative "../services/inventory"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi marked [--mine] [--project DIR] [--vm UUID] [--box NAME] [--plain|--json]
+      #
+      # Lists the objects in the pool that carry the plugin's marking, through
+      # XAPI with the normal connection settings (no dom0 access needed).
+      class Marked < Base
+        def execute
+          options = { projects: [], vm_uuids: [], boxes: [], mine: false, style: :table }
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant xapi marked [--mine] [--project DIR] [--vm UUID] [--box NAME] [--plain|--json]"
+            o.separator ""
+            o.separator "Without filters: every marked object in the pool. Filters can be repeated;"
+            o.separator "an object is listed when it belongs to any of them."
+            o.separator ""
+            o.on("--mine", "VMs of this Vagrant installation, their snapshots, disks and internal networks") do
+              options[:mine] = true
+            end
+            o.on("--project DIR", "VMs, snapshots and internal networks of this project directory") do |d|
+              options[:projects].concat(project_paths(d))
+            end
+            o.on("--vm UUID", "This VM, its snapshots and the disks it owns") { |u| options[:vm_uuids] << u }
+            o.on("--box NAME", "Templates of this box") { |b| options[:boxes] << b }
+            o.on("--plain", "One object per line, tab-separated, no header (for scripts)") { options[:style] = :plain }
+            o.on("--json", "JSON") { options[:style] = :json }
+          end
+          argv = parse_options(opts)
+          return 0 if argv.nil?
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp unless argv.empty?
+
+          machine = connection_machine
+          objects = Errors.wrap do
+            Services::Inventory.new(Glue.context(machine))
+                               .marked(projects: options[:projects], vm_uuids: options[:vm_uuids],
+                                       boxes: options[:boxes],
+                                       mine: options[:mine] ? Glue.client_id(@env) : nil)
+          end
+          print_objects(objects, options[:style])
+          0
+        end
+
+        private
+
+        # Vagrant marks the physical path (e.g. /private/var/... on macOS, where
+        # /var is a symlink); match both that and the path as given.
+        def project_paths(dir)
+          given = File.expand_path(dir)
+          real = File.exist?(given) ? File.realpath(given) : given
+          [given, real].uniq
+        end
+
+        def print_objects(objects, style)
+          case style
+          when :json
+            @env.ui.info(JSON.pretty_generate(objects.map(&:to_h)), prefix: false)
+          when :plain
+            return if objects.empty?
+
+            @env.ui.info(objects.map { |m| [m.kind, m.uuid, m.name, m.detail].join("\t") }.join("\n"),
+                         prefix: false)
+          else
+            if objects.empty?
+              @env.ui.info(t("nothing_marked"))
+              return
+            end
+            lines = [format("%-9s %-36s %-40s %s", "KIND", "UUID", "NAME", "DETAIL")]
+            objects.each do |m|
+              lines << format("%-9s %-36s %-40s %s", m.kind, m.uuid, m.name.to_s[0, 40], m.detail)
+            end
+            @env.ui.info(lines.join("\n"), prefix: false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/command/orphans.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require_relative "base"
+require_relative "../services/inventory"
+require_relative "../services/destroyer"
+require_relative "../services/networks"
+require_relative "../services/power"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi orphans [--destroy]: VMs of this Vagrant installation
+      # whose Vagrant machine no longer exists locally.
+      class Orphans < Base
+        def execute
+          options = { destroy: false, force: false }
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant xapi orphans [--destroy] [--force]"
+            o.on("--destroy", "Destroy the orphaned VMs") { options[:destroy] = true }
+            o.on("-f", "--force", "Do not ask for confirmation") { options[:force] = true }
+          end
+          argv = parse_options(opts)
+          return 0 if argv.nil?
+
+          machine = connection_machine
+          Errors.wrap do
+            ctx = Glue.context(machine)
+            orphans = Services::Inventory.new(ctx).my_vms(client_id: Glue.client_id(@env))
+                                                  .reject { |vm| machine_exists?(vm) }
+            if orphans.empty?
+              @env.ui.info(t("no_orphans"))
+              return 0
+            end
+
+            orphans.each do |vm|
+              @env.ui.info(t("orphan", name: vm.name, uuid: vm.uuid, machine: vm.machine,
+                                       project: vm.project, state: vm.power_state))
+            end
+            return options[:destroy] ? destroy(ctx, orphans, options[:force]) : 0
+          end
+        end
+
+        private
+
+        # The machine still exists when some Vagrant machine (from Vagrant's
+        # machine index, which knows custom VAGRANT_DOTFILE_PATHs) or the
+        # project's default .vagrant directory has an id file with this
+        # VM's UUID.
+        def machine_exists?(vm)
+          return false if vm.machine.to_s.empty?
+
+          data_dirs = []
+          @env.machine_index.each do |entry|
+            next unless Extensions.provider?(entry.provider) && entry.name.to_s == vm.machine.to_s
+            next unless entry.local_data_path
+
+            data_dirs << Pathname.new(entry.local_data_path.to_s)
+          end
+          data_dirs << Pathname.new(vm.project).join(".vagrant") unless vm.project.to_s.empty?
+          data_dirs.uniq.product(Extensions.provider_names).any? do |dir, provider|
+            id_file = dir.join("machines", vm.machine, provider.to_s, "id")
+            id_file.file? && id_file.read.strip == vm.uuid
+          end
+        end
+
+        # A VM that cannot be shut down or removed (another operation on it,
+        # a lost connection) is reported and the others still go; the
+        # command then exits with 1.
+        # @return [Integer] exit status
+        def destroy(ctx, orphans, force)
+          return 0 unless confirm(t("confirm_orphans_destroy", count: orphans.size), force)
+
+          failed = orphans.count { |vm| !destroy_one(ctx, vm) }
+          failed.zero? ? 0 : 1
+        end
+
+        def destroy_one(ctx, vm)
+          # As `vagrant destroy`: a task, so a slow shutdown is no API
+          # timeout, and only when the VM is not already halted.
+          Services::Power.new(ctx).hard_shutdown(vm.ref)
+          used = Services::Destroyer.new(ctx).destroy(vm.ref)
+          Services::Networks.new(ctx, project: vm.project).cleanup_unused(used)
+          @env.ui.success(t("orphan_destroyed", name: vm.name, uuid: vm.uuid))
+          true
+        rescue Api::TaskCancelled
+          raise
+        rescue Api::Error, Services::Error => e
+          @env.ui.error(t("orphan_destroy_failed", name: vm.name, uuid: vm.uuid, reason: Errors.translate(e).message))
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/command/root.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require_relative "../extensions"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi <subcommand>: what Vagrant core does not cover.
+      class Root < Vagrant.plugin("2", :command)
+        SUBCOMMANDS = {
+          info: ["info", "Info", "UUID, host, SR, template, VIFs with IPs, snapshots"],
+          console: ["console", "Console", "VNC console through the XAPI console tunnel"],
+          adopt: ["adopt", "Adopt", "attach an existing VM to this machine"],
+          templates: ["templates", "Templates", "list, prune or remove box templates"],
+          orphans: ["orphans", "Orphans", "VMs of this Vagrant installation whose machine is gone"],
+          marked: ["marked", "Marked", "everything in the pool that vagrant-xapi created"],
+          diff: ["diff", "Diff", "files that differ from a snapshot or another machine"],
+          hosts: ["hosts", "Hosts", "the pool's hosts with address, role and TLS fingerprint"]
+        }.freeze
+
+        def self.synopsis
+          "manages XAPI-specific things (vagrant-xapi)"
+        end
+
+        def execute
+          main_args, sub_command, sub_args = split_main_and_subcommand(@argv)
+          if main_args.include?("-h") || main_args.include?("--help") || sub_command.nil?
+            return help
+          end
+
+          entry = subcommands[sub_command.to_sym]
+          return help unless entry
+
+          require_relative entry[0]
+          Command.const_get(entry[1]).new(sub_args, @env).execute
+        end
+
+        def subcommands
+          SUBCOMMANDS.merge(Extensions.subcommands)
+        end
+
+        def help
+          lines = ["Usage: vagrant xapi <subcommand> [<args>]", "", "Subcommands:"]
+          subcommands.each { |name, (_file, _klass, desc)| lines << format("    %-10s %s", name, desc) }
+          lines << ""
+          lines << "For help on a subcommand run `vagrant xapi <subcommand> -h`."
+          @env.ui.info(lines.join("\n"), prefix: false)
+          0
+        end
+      end
+    end
+  end
+end