vagrant-xapi 0.0.1 → 1.0.0

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../services/inventory"
+
+module VagrantPlugins
+  module Xapi
+    module Command
+      # vagrant xapi templates list | prune [--keep N] | remove NAME|UUID
+      #
+      # Templates are shared by every user of a pool, so prune and remove show
+      # which other users still have clones before asking for confirmation.
+      class Templates < Base
+        def execute
+          options = { keep: 1, force: false }
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant xapi templates list|prune|remove [NAME|UUID] [--keep N] [--force]"
+            o.on("--keep N", Integer, "prune: newest versions to keep per box (default 1)") { |n| options[:keep] = n }
+            o.on("-f", "--force", "Do not ask for confirmation") { options[:force] = true }
+          end
+          argv = parse_options(opts)
+          return 0 if argv.nil?
+
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if options[:keep].negative?
+
+          action = argv.shift || "list"
+          machine = connection_machine
+          Errors.wrap do
+            inventory = Services::Inventory.new(Glue.context(machine))
+            case action
+            when "list" then list(inventory)
+            when "prune" then prune(inventory, options)
+            when "remove"
+              raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.empty?
+
+              remove(inventory, argv.first, options)
+            else
+              raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp
+            end
+          end
+          0
+        end
+
+        private
+
+        def list(inventory)
+          rows = inventory.templates
+          if rows.empty?
+            @env.ui.info(t("no_templates"))
+            return
+          end
+
+          header = format("%-30s %-12s %-10s %-20s %10s %7s  %s", "BOX", "VERSION", "PROVIDER", "SR", "SIZE",
+                          "CLONES", "UUID")
+          lines = [header]
+          rows.each do |r|
+            lines << format("%-30s %-12s %-10s %-20s %10s %7d  %s", r.box, r.version, r.provider, r.sr_name,
+                            human_size(r.size), r.clones, r.uuid)
+          end
+          @env.ui.info(lines.join("\n"), prefix: false)
+        end
+
+        def prune(inventory, options)
+          candidates = inventory.prune_candidates(options[:keep])
+          if candidates.empty?
+            @env.ui.info(t("nothing_to_prune"))
+            return
+          end
+          candidates.each { |c| remove_one(inventory, c, options[:force]) }
+        end
+
+        def remove(inventory, name, options)
+          remove_one(inventory, inventory.find_template(name), options[:force])
+        end
+
+        def remove_one(inventory, info, force)
+          @env.ui.info(t("template_summary", name: info.name, uuid: info.uuid, clones: info.clones))
+          others = info.clone_users - [Services::Marking.user]
+          @env.ui.warn(t("template_other_users", users: others.join(", "))) unless others.empty?
+          unless confirm(t("confirm_template_remove", name: info.name), force)
+            @env.ui.info(t("skipped"))
+            return
+          end
+
+          inventory.remove_template(info)
+          @env.ui.success(t("template_removed", name: info.name))
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/config.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "vagrant"
+require "vagrant/util/platform"
+require "vagrant/util/scoped_hash_override"
+
+require_relative "extensions"
+
+module VagrantPlugins
+  module Xapi
+    # Provider configuration: config.vm.provider :xapi do |xapi| ... end
+    #
+    # Only host, username and password are required, and all three can come
+    # from VAGRANT_XAPI_HOST, VAGRANT_XAPI_USERNAME and VAGRANT_XAPI_PASSWORD.
+    class Config < Vagrant.plugin("2", :config)
+      include Vagrant::Util::ScopedHashOverride
+      FIRMWARES = %i[bios uefi].freeze
+      CLONE_MODES = %i[fast full].freeze
+      PACKAGE_FORMATS = %i[xva vhd qcow2].freeze
+      IP_SOURCES = %i[guest_metrics static himn].freeze
+      FINGERPRINT_RE = /\A(?:[0-9a-fA-F]{2}:){31}[0-9a-fA-F]{2}\z|\A[0-9a-fA-F]{64}\z/.freeze
+      RESERVED_PREFIX = "vagrant-xapi."
+
+      # Connection
+      attr_accessor :host, :port, :username, :password
+      attr_accessor :tls_verify, :tls_ca_file, :tls_fingerprint
+      attr_accessor :api_timeout, :task_timeout
+
+      # VM
+      attr_accessor :name_label, :cpus, :cores_per_socket, :memory, :memory_dynamic_min
+      attr_accessor :firmware, :secure_boot, :vtpm
+      attr_accessor :sr, :template_sr, :clone_mode, :affinity_host
+      attr_accessor :tags, :platform, :other_config, :xva_url, :isos
+
+      # Network / SSH
+      attr_accessor :default_network, :ip_detection, :ssh_via_host, :host_ssh_user
+      attr_accessor :forward_ssh_port
+
+      # Lifecycle
+      attr_accessor :shutdown_timeout, :snapshot_memory, :package_format
+
+      def initialize
+        super
+        @host = UNSET_VALUE
+        @port = UNSET_VALUE
+        @username = UNSET_VALUE
+        @password = UNSET_VALUE
+        @tls_verify = UNSET_VALUE
+        @tls_ca_file = UNSET_VALUE
+        @tls_fingerprint = UNSET_VALUE
+        @api_timeout = UNSET_VALUE
+        @task_timeout = UNSET_VALUE
+
+        @name_label = UNSET_VALUE
+        @cpus = UNSET_VALUE
+        @cores_per_socket = UNSET_VALUE
+        @memory = UNSET_VALUE
+        @memory_dynamic_min = UNSET_VALUE
+        @firmware = UNSET_VALUE
+        @secure_boot = UNSET_VALUE
+        @vtpm = UNSET_VALUE
+        @sr = UNSET_VALUE
+        @template_sr = UNSET_VALUE
+        @clone_mode = UNSET_VALUE
+        @affinity_host = UNSET_VALUE
+        @tags = UNSET_VALUE
+        @platform = UNSET_VALUE
+        @other_config = UNSET_VALUE
+        @xva_url = UNSET_VALUE
+        @isos = UNSET_VALUE
+
+        @default_network = UNSET_VALUE
+        @ip_detection = UNSET_VALUE
+        @ssh_via_host = UNSET_VALUE
+        @host_ssh_user = UNSET_VALUE
+        @forward_ssh_port = UNSET_VALUE
+
+        @shutdown_timeout = UNSET_VALUE
+        @snapshot_memory = UNSET_VALUE
+        @package_format = UNSET_VALUE
+      end
+
+      # Lists and hashes are combined instead of replaced.
+      def merge(other)
+        super.tap do |result|
+          result.tags = merge_list(@tags, other.tags)
+          result.isos = merge_list(@isos, other.isos)
+          result.platform = merge_hash(@platform, other.platform)
+          result.other_config = merge_hash(@other_config, other.other_config)
+        end
+      end
+
+      def finalize!
+        @host = env_default(@host, "VAGRANT_XAPI_HOST")
+        @username = env_default(@username, "VAGRANT_XAPI_USERNAME")
+        @password = env_default(@password, "VAGRANT_XAPI_PASSWORD")
+        @port = 443 if @port == UNSET_VALUE
+        @tls_verify = true if @tls_verify == UNSET_VALUE
+        @tls_ca_file = env_default(@tls_ca_file, "VAGRANT_XAPI_TLS_CA_FILE")
+        @tls_fingerprint = env_default(@tls_fingerprint, "VAGRANT_XAPI_TLS_FINGERPRINT")
+        @api_timeout = 60 if @api_timeout == UNSET_VALUE
+        @task_timeout = 3600 if @task_timeout == UNSET_VALUE
+
+        @name_label = nil if @name_label == UNSET_VALUE
+        @cpus = nil if @cpus == UNSET_VALUE
+        @cores_per_socket = nil if @cores_per_socket == UNSET_VALUE
+        @memory = nil if @memory == UNSET_VALUE
+        @memory_dynamic_min = nil if @memory_dynamic_min == UNSET_VALUE
+        @firmware = @firmware == UNSET_VALUE || @firmware.nil? ? nil : @firmware.to_sym
+        @secure_boot = false if @secure_boot == UNSET_VALUE
+        @vtpm = false if @vtpm == UNSET_VALUE
+        @sr = nil if @sr == UNSET_VALUE
+        @template_sr = nil if @template_sr == UNSET_VALUE
+        @clone_mode = @clone_mode == UNSET_VALUE ? :fast : @clone_mode.to_sym
+        @affinity_host = nil if @affinity_host == UNSET_VALUE
+        @tags = [] if @tags == UNSET_VALUE
+        @platform = {} if @platform == UNSET_VALUE
+        @other_config = {} if @other_config == UNSET_VALUE
+        @xva_url = nil if @xva_url == UNSET_VALUE
+        @isos = [] if @isos == UNSET_VALUE
+
+        @default_network = env_default(@default_network, "VAGRANT_XAPI_DEFAULT_NETWORK")
+        @ip_detection = @ip_detection == UNSET_VALUE ? IP_SOURCES.dup : Array(@ip_detection).map(&:to_sym)
+        @ssh_via_host = false if @ssh_via_host == UNSET_VALUE
+        @host_ssh_user = "root" if @host_ssh_user == UNSET_VALUE
+        @forward_ssh_port = false if @forward_ssh_port == UNSET_VALUE
+
+        @shutdown_timeout = 120 if @shutdown_timeout == UNSET_VALUE
+        @snapshot_memory = false if @snapshot_memory == UNSET_VALUE
+        @package_format = @package_format == UNSET_VALUE ? :xva : @package_format.to_sym
+        Extensions.config_finalized(self)
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+        t = ->(key, **opts) { I18n.t("vagrant_xapi.config.#{key}", **opts) }
+
+        errors << t.call(:host_required) if blank?(@host)
+        errors << t.call(:username_required) if blank?(@username)
+        errors << t.call(:password_required) if blank?(@password)
+        errors << t.call(:port_invalid) unless @port.is_a?(Integer) && @port.between?(1, 65_535)
+
+        pins = fingerprint_entries
+        errors << t.call(:tls_verify_off) if @tls_verify == false && pins.empty?
+        if @tls_fingerprint && (pins.empty? || !pins.all? { |pin| FINGERPRINT_RE.match?(pin) })
+          errors << t.call(:fingerprint_invalid)
+        end
+        if @tls_ca_file && !File.file?(File.expand_path(@tls_ca_file.to_s, machine.env.root_path.to_s))
+          errors << t.call(:ca_file_missing, path: @tls_ca_file)
+        end
+
+        %i[api_timeout task_timeout shutdown_timeout].each do |opt|
+          v = instance_variable_get("@#{opt}")
+          errors << t.call(:positive_integer, option: opt) unless v.is_a?(Integer) && v.positive?
+        end
+
+        validate_cpu_memory(errors, t)
+        validate_enums(errors, t)
+        validate_firmware(errors, t)
+        validate_maps(errors, t)
+        validate_networks(machine, errors, t)
+        validate_disks(machine, errors, t)
+        warn_architecture(machine)
+
+        { "XAPI provider" => errors }
+      end
+
+      # Never show the password.
+      def to_s
+        "XAPI"
+      end
+
+      def instance_variables_hash
+        super.tap { |h| h["password"] = "[REDACTED]" if h.key?("password") && h["password"] }
+      end
+
+      def inspect
+        "#<#{self.class.name} host=#{@host.inspect} username=#{@username.inspect} password=[REDACTED]>"
+      end
+
+      private
+
+      def validate_cpu_memory(errors, t)
+        if @cpus
+          if !@cpus.is_a?(Integer) || @cpus < 1
+            errors << t.call(:cpus_invalid)
+          elsif @cores_per_socket && (@cores_per_socket.to_i < 1 || (@cpus % @cores_per_socket.to_i) != 0)
+            errors << t.call(:cores_per_socket_invalid, cpus: @cpus, cores: @cores_per_socket)
+          end
+        elsif @cores_per_socket && (!@cores_per_socket.is_a?(Integer) || @cores_per_socket < 1)
+          errors << t.call(:cores_per_socket_positive)
+        end
+
+        if @memory
+          errors << t.call(:memory_invalid) if !@memory.is_a?(Integer) || @memory < 256
+          if @memory_dynamic_min && @memory.is_a?(Integer) && @memory < @memory_dynamic_min.to_i
+            errors << t.call(:memory_below_dynamic_min, memory: @memory, min: @memory_dynamic_min)
+          end
+        end
+        if @memory_dynamic_min && (!@memory_dynamic_min.is_a?(Integer) || @memory_dynamic_min < 256)
+          errors << t.call(:memory_dynamic_min_invalid)
+        end
+      end
+
+      def validate_enums(errors, t)
+        if @firmware && !FIRMWARES.include?(@firmware)
+          errors << t.call(:enum_invalid, option: "firmware", value: @firmware, allowed: FIRMWARES.join(", "))
+        end
+        unless CLONE_MODES.include?(@clone_mode)
+          errors << t.call(:enum_invalid, option: "clone_mode", value: @clone_mode, allowed: CLONE_MODES.join(", "))
+        end
+        unless PACKAGE_FORMATS.include?(@package_format)
+          errors << t.call(:enum_invalid, option: "package_format", value: @package_format,
+                                          allowed: PACKAGE_FORMATS.join(", "))
+        end
+        bad = @ip_detection - IP_SOURCES
+        unless bad.empty? && !@ip_detection.empty?
+          errors << t.call(:enum_invalid, option: "ip_detection", value: bad.join(", "),
+                                          allowed: IP_SOURCES.join(", "))
+        end
+        if @ip_detection == [:himn] && !@ssh_via_host
+          errors << t.call(:himn_needs_ssh_via_host)
+        end
+      end
+
+      def validate_firmware(errors, t)
+        errors << t.call(:secure_boot_needs_uefi) if @secure_boot && @firmware != :uefi
+        errors << t.call(:vtpm_needs_uefi) if @vtpm && @firmware != :uefi
+      end
+
+      def validate_maps(errors, t)
+        errors << t.call(:hash_expected, option: "platform") unless @platform.is_a?(Hash)
+        if @other_config.is_a?(Hash)
+          reserved = @other_config.keys.map(&:to_s).select { |k| k.start_with?(RESERVED_PREFIX) }
+          errors << t.call(:other_config_reserved, keys: reserved.join(", ")) unless reserved.empty?
+        else
+          errors << t.call(:hash_expected, option: "other_config")
+        end
+        errors << t.call(:array_expected, option: "tags") unless @tags.is_a?(Array)
+        errors << t.call(:array_expected, option: "isos") unless @isos.is_a?(Array)
+      end
+
+      def validate_networks(machine, errors, t)
+        machine.config.vm.networks.each do |type, opts|
+          case type
+          when :forwarded_port
+            next if opts[:id] == "ssh" && !@forward_ssh_port
+            # Never forwarded (Glue.forwarded_ports), so nothing to check.
+            next if opts[:disabled]
+
+            if opts[:protocol].to_s == "udp"
+              errors << t.call(:forwarded_port_udp, guest: opts[:guest], host: opts[:host])
+            end
+            if opts[:host].to_i < 1024
+              errors << t.call(:forwarded_port_privileged, host: opts[:host])
+            end
+          when :private_network
+            scoped = scoped_options(opts)
+            if scoped[:network].nil? && scoped[:bridge].nil?
+              if blank?(scoped[:ip]) || scoped[:type].to_s == "dhcp"
+                errors << t.call(:private_network_needs_ip)
+              end
+            end
+          end
+        end
+      end
+
+      def validate_disks(machine, errors, t)
+        machine.config.vm.disks.each do |disk|
+          errors << t.call(:floppy_unsupported, name: disk.name) if disk.type == :floppy
+        end
+      end
+
+      # Only while Vagrant still has to find or download the box: with
+      # box_architecture :auto it then looks for one of this computer's
+      # architecture, which XenServer and XCP-ng cannot run. A box that is
+      # already there was found, so there is nothing to say (Vagrantfiles of
+      # vagrant-xenserver on an arm64 Mac, say).
+      def warn_architecture(machine)
+        return if self.class.instance_variable_get(:@arch_warned)
+        return unless machine.config.vm.box_architecture.to_s == "auto"
+
+        host_arch = Vagrant::Util::Platform.architecture.to_s
+        return if host_arch == "amd64"
+        return if machine.config.vm.box.to_s.empty? || box_present?(machine)
+
+        self.class.instance_variable_set(:@arch_warned, true)
+        machine.ui.warn(I18n.t("vagrant_xapi.config.architecture_warning", arch: host_arch))
+      end
+
+      def box_present?(machine)
+        !machine.box.nil?
+      rescue StandardError
+        false
+      end
+
+      def scoped_options(opts)
+        scoped_hash_override(opts, :xapi)
+      end
+
+      def env_default(value, var)
+        return value unless value == UNSET_VALUE
+
+        ENV[var].nil? || ENV[var].empty? ? nil : ENV[var]
+      end
+
+      # tls_fingerprint: one fingerprint, several separated by commas or
+      # whitespace, or an Array of them.
+      def fingerprint_entries
+        Array(@tls_fingerprint).flat_map { |v| v.to_s.split(/[\s,]+/) }.reject(&:empty?)
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def merge_list(a, b)
+        a = [] if a == UNSET_VALUE
+        b = [] if b == UNSET_VALUE
+        return b if a.nil?
+        return a if b.nil?
+
+        (Array(a) + Array(b)).uniq
+      end
+
+      def merge_hash(a, b)
+        a = {} if a == UNSET_VALUE
+        b = {} if b == UNSET_VALUE
+        (a || {}).merge(b || {})
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/errors.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "vagrant"
+
+require_relative "api/errors"
+require_relative "api/redactor"
+require_relative "services/base"
+
+module VagrantPlugins
+  module Xapi
+    # Every error the user can see is a VagrantError with text from
+    # locales/en.yml. A stack trace is a bug.
+    module Errors
+      class XapiError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_xapi.errors")
+
+        # A missing interpolation value must never turn into a stack trace.
+        def translate_error(opts)
+          values = opts.dup
+          5.times do
+            return super(values)
+          rescue I18n::MissingInterpolationArgument => e
+            values[e.key.to_sym] = "?"
+          end
+          super(values)
+        end
+
+        # Never let a secret slip into a message (Exception#message calls
+        # to_s).
+        def to_s
+          Api::Redactor.scrub(super)
+        end
+      end
+
+      # Specific classes so callers can rescue them by type.
+      class ConnectionFailed < XapiError
+        error_key(:connection_failed)
+      end
+
+      class AuthFailed < XapiError
+        error_key(:auth_failed)
+      end
+
+      class ServiceFailed < XapiError; end
+
+      XAPI_CODES = {
+        "SESSION_AUTHENTICATION_FAILED" => :auth_failed,
+        "RBAC_PERMISSION_DENIED" => :permission_denied,
+        "SR_FULL" => :sr_full,
+        "SR_BACKEND_FAILURE_44" => :sr_full,
+        "HOST_NOT_ENOUGH_FREE_MEMORY" => :not_enough_memory,
+        "NO_HOSTS_AVAILABLE" => :no_hosts_available,
+        "VM_BAD_POWER_STATE" => :bad_power_state,
+        "LICENCE_RESTRICTION" => :licence_restriction,
+        "VM_REQUIRES_SR" => :vm_requires_sr,
+        "VM_REQUIRES_NETWORK" => :vm_requires_network,
+        "OPERATION_NOT_ALLOWED" => :operation_not_allowed,
+        "OTHER_OPERATION_IN_PROGRESS" => :operation_in_progress,
+        "VM_MISSING_PV_DRIVERS" => :suspend_no_drivers,
+        "VDI_IN_USE" => :vdi_in_use,
+        "HOST_OFFLINE" => :host_offline
+      }.freeze
+
+      module_function
+
+      # Turns any client or service error into a VagrantError.
+      # @return [Exception] the translated error, or the original one
+      def translate(error)
+        case error
+        when Vagrant::Errors::VagrantError
+          error
+        when Services::Error
+          key = error.key
+          key = :generic_service_error unless I18n.exists?("vagrant_xapi.errors.#{key}")
+          ServiceFailed.new(key, scrub(error.params).merge(error_key: error.key.to_s))
+        when Api::XapiError
+          key = XAPI_CODES[error.code] || :xapi_error
+          ServiceFailed.new(key, code: error.code, params: scrub(error.params.join(", ")),
+                                 method: error.method_name.to_s,
+                                 first: scrub(error.params[0].to_s), second: scrub(error.params[1].to_s),
+                                 third: scrub(error.params[2].to_s))
+        when Api::ConnectionError
+          ConnectionFailed.new(host: error.host, reason: scrub(error.reason))
+        when Api::TlsError
+          ServiceFailed.new(:tls_failed, host: error.host, reason: scrub(error.reason))
+        when Api::PoolMemberError
+          ServiceFailed.new(:pool_member_pinned, host: error.host, master: error.master)
+        when Api::TaskTimeout
+          ServiceFailed.new(:task_timeout, label: error.label, timeout: error.timeout)
+        when Api::TaskCancelled
+          ServiceFailed.new(:cancelled, label: error.label)
+        when Api::HttpError
+          ServiceFailed.new(:http_error, status: error.status, path: error.path, detail: scrub(error.message))
+        when Api::Error
+          ServiceFailed.new(:protocol_error, detail: scrub(error.message))
+        else
+          error
+        end
+      end
+
+      # Runs the block and re-raises client/service errors as VagrantErrors.
+      def wrap
+        yield
+      rescue Api::Error, Services::Error => e
+        raise translate(e)
+      end
+
+      def scrub(value)
+        Api::Redactor.scrub(value)
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/extensions.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module Xapi
+    # Places where a layer hooks into the core: the compatibility with
+    # vagrant-xenserver (lib/vagrant-xapi/xenserver) and the temporary
+    # XenApi stand-in (lib/vagrant-xapi/legacy); see docs/architecture.md,
+    # section 17. The core only calls these and never names a layer.
+    # Without one, they change nothing.
+    module Extensions
+      @provider_names = [:xapi]
+      @id_resolvers = []
+      @before_destroy = []
+      @config_finalized = []
+      @subcommands = {}
+
+      class << self
+        # Providers whose machines this plugin runs: their data dirs
+        # (machines/<name>/<provider>), entries in Vagrant's machine index,
+        # and the machines `vagrant xapi` works on.
+        def provider_names
+          @provider_names.dup
+        end
+
+        def add_provider_name(name)
+          @provider_names |= [name.to_sym]
+        end
+
+        def provider?(name)
+          !name.nil? && @provider_names.include?(name.to_s.to_sym)
+        end
+
+        # block.call(machine, ctx) when machine.id is not a VM UUID, e.g. an
+        # id written by another plugin. It may set machine.id to a VM UUID.
+        def on_foreign_id(&block)
+          @id_resolvers << block
+        end
+
+        def resolve_foreign_id(machine, ctx)
+          # Here, not at the top: plugin.rb loads this file before any service.
+          require_relative "services/lookup"
+          @id_resolvers.each do |resolver|
+            resolver.call(machine, ctx)
+            break if machine.id.nil? || Services::Lookup.uuid?(machine.id)
+          end
+        end
+
+        # block.call(machine, ctx, vm_ref) before `vagrant destroy` removes
+        # the VM, e.g. to mark more disks as the VM's own.
+        def on_before_destroy(&block)
+          @before_destroy << block
+        end
+
+        def before_destroy(machine, ctx, vm_ref)
+          @before_destroy.each { |hook| hook.call(machine, ctx, vm_ref) }
+        end
+
+        # block.call(config) after a provider config (of any of
+        # provider_names) was finalized.
+        def on_config_finalized(&block)
+          @config_finalized << block
+        end
+
+        def config_finalized(config)
+          @config_finalized.each { |hook| hook.call(config) }
+        end
+
+        # Extra `vagrant xapi` subcommands: name => [file to require, class
+        # name in Command, description].
+        def add_subcommand(name, file, klass, description)
+          @subcommands[name.to_sym] = [file, klass, description]
+        end
+
+        def subcommands
+          @subcommands.dup
+        end
+      end
+    end
+  end
+end