vagrant-xapi 0.0.1 → 1.0.0

data/lib/vagrant-xapi/glue.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "log4r"
+require "pathname"
+require "securerandom"
+require "vagrant/util/scoped_hash_override"
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+require_relative "api/session_registry"
+require_relative "errors"
+require_relative "services/base"
+require_relative "services/lookup"
+require_relative "services/networks"
+require_relative "services/ip_detector"
+require_relative "services/vm_builder"
+require_relative "services/tunnels"
+
+module VagrantPlugins
+  module Xapi
+    # Translates between Vagrant (machine, config, ui) and the services.
+    # This is the only place besides actions/caps/commands that knows both.
+    module Glue
+      extend Vagrant::Util::ScopedHashOverride
+
+      # Under "vagrantplugins", so VAGRANT_LOG shows it (Vagrant only sets up
+      # the "vagrant" and "vagrantplugins" loggers). Lines appear as "xapi: ...".
+      LOGGER = Log4r::Logger.new("vagrantplugins::xapi")
+
+      # Maps service message keys to Vagrant UI output, with progress on one
+      # rewritten line.
+      class UiAdapter
+        def initialize(ui)
+          @ui = ui
+          @last = nil
+        end
+
+        def info(key, **params)
+          @ui&.info(t(key, **params))
+        end
+
+        def detail(key, **params)
+          @ui&.detail(t(key, **params))
+        end
+
+        def warn(key, **params)
+          @ui&.warn(t(key, **params))
+        end
+
+        def progress(key, done, total, **params)
+          return unless @ui
+
+          pct = total.to_f.positive? ? (done.to_f / total * 100).floor : nil
+          text = pct ? "#{t(key, **params)} #{pct}%" : "#{t(key, **params)} #{format_bytes(done)}"
+          return if text == @last
+
+          @last = text
+          @ui.clear_line
+          @ui.detail(text, new_line: false)
+        end
+
+        def clear_progress
+          return unless @ui && @last
+
+          @ui.clear_line
+          @last = nil
+        end
+
+        private
+
+        def t(key, **params)
+          Api::Redactor.scrub(I18n.t("vagrant_xapi.messages.#{key}", **params))
+        end
+
+        def format_bytes(n)
+          return "#{n} B" if n < 1024
+          return format("%.1f MiB", n / 1024.0**2) if n < 1024**3
+
+          format("%.2f GiB", n / 1024.0**3)
+        end
+      end
+
+      module_function
+
+      def client(machine)
+        cfg = machine.provider_config
+        missing = { host: cfg.host, username: cfg.username, password: cfg.password }
+                  .select { |_k, v| v.nil? || v.to_s.empty? }.keys
+        raise Errors::ServiceFailed.new(:missing_credentials, options: missing.join(", ")) unless missing.empty?
+
+        Errors.wrap do
+          Api::SessionRegistry.fetch(
+            host: cfg.host, port: cfg.port, username: cfg.username, password: cfg.password,
+            tls: tls(cfg, machine.env.root_path), api_timeout: cfg.api_timeout, task_timeout: cfg.task_timeout,
+            logger: LOGGER
+          )
+        end
+      end
+
+      # tls_ca_file is relative to the Vagrantfile's directory, like the
+      # check in Config#validate (Vagrant may run from a subdirectory).
+      def tls(cfg, root = nil)
+        {
+          verify: true,
+          ca_file: cfg.tls_ca_file ? File.expand_path(cfg.tls_ca_file.to_s, root ? root.to_s : Dir.pwd) : nil,
+          fingerprint: cfg.tls_fingerprint
+        }.compact
+      end
+
+      # Runs commands in a machine's guest for the services (as root, through
+      # Vagrant's communicator), see Services::GuestFiles.
+      class GuestShell
+        def initialize(machine)
+          @machine = machine
+        end
+
+        # @return [Array(Integer, String, String)] exit status, stdout, stderr
+        def run(command)
+          out = +""
+          err = +""
+          status = @machine.communicate.execute(command, sudo: true, error_check: false) do |type, data|
+            (type == :stdout ? out : err) << data.to_s.b
+          end
+          [status.to_i, out, err]
+        end
+
+        def upload(local, remote)
+          @machine.communicate.upload(local, remote)
+        end
+
+        def download(remote, local)
+          @machine.communicate.download(remote, local)
+        end
+      end
+
+      # @param env [Hash, nil] action env (for env[:interrupted] and env[:ui])
+      # @param cancel [#call, nil] Ctrl-C flag of a command
+      # @param ui [Vagrant::UI::Interface, nil] instead of the machine's UI
+      def context(machine, env = nil, client: nil, cancel: nil, ui: nil)
+        ui ||= (env && env[:ui]) || machine.ui
+        cancel ||= if env
+                     -> { env[:interrupted] ? true : false }
+                   else
+                     Thread.current[:vagrant_xapi_cancel]
+                   end
+        Services::Context.new(
+          client: client || self.client(machine),
+          ui: UiAdapter.new(ui),
+          cancel: cancel,
+          logger: LOGGER
+        )
+      end
+
+      # @return [String, nil] VM ref, nil when the machine is not created
+      def vm_ref(machine, ctx)
+        return nil if machine.id.nil?
+
+        Errors.wrap { Services::Lookup.new(ctx).vm_by_uuid(machine.id) }
+      end
+
+      def project_path(machine)
+        machine.env.root_path.to_s
+      end
+
+      def name_label(machine)
+        machine.provider_config.name_label ||
+          "#{File.basename(machine.env.root_path.to_s)}_#{machine.name}"
+      end
+
+      def vm_spec(machine)
+        cfg = machine.provider_config
+        Services::VmSpec.new(
+          name_label: name_label(machine),
+          description: "Vagrant machine '#{machine.name}' of #{project_path(machine)} (vagrant-xapi)",
+          cpus: cfg.cpus,
+          cores_per_socket: cfg.cores_per_socket,
+          memory: cfg.memory,
+          memory_dynamic_min: cfg.memory_dynamic_min,
+          firmware: cfg.firmware,
+          # BIOS cannot boot securely: a VM switched from :uefi to :bios
+          # loses platform:secureboot. Without firmware the template decides.
+          secure_boot: { uefi: cfg.secure_boot, bios: false }[cfg.firmware],
+          vtpm: cfg.vtpm,
+          affinity_host: cfg.affinity_host,
+          tags: cfg.tags,
+          platform: cfg.platform,
+          other_config: cfg.other_config,
+          marking: Services::Marking.vm_marking(machine_name: machine.name, project: project_path(machine),
+                                                client_id: client_id(machine.env))
+        )
+      end
+
+      # Vagrant networks with xapi__ options applied.
+      def networks(machine)
+        machine.config.vm.networks.map do |type, opts|
+          [type, scoped_hash_override(opts || {}, :xapi)]
+        end
+      end
+
+      def himn?(machine)
+        cfg = machine.provider_config
+        cfg.ip_detection.include?(:himn) && cfg.ssh_via_host
+      end
+
+      def vif_plan(machine)
+        Services::Networks.plan(networks(machine),
+                                default_network: machine.provider_config.default_network,
+                                himn: himn?(machine),
+                                project: project_path(machine))
+      end
+
+      # ip: of VIF device 0, if static
+      def static_ip(machine)
+        first = vif_plan(machine).first
+        first&.static_ip? ? first.ip.to_s : nil
+      end
+
+      def ip_detector(machine, ctx)
+        Services::IpDetector.new(ctx, sources: machine.provider_config.ip_detection,
+                                      static_ip: static_ip(machine), himn_enabled: himn?(machine))
+      end
+
+      # Option key under which PrepareForwardedPortCollisionParams keeps the
+      # Vagrantfile's host port, before HandleForwardedPortCollisions
+      # overwrites options[:host] with an auto-corrected one.
+      CONFIGURED_HOST = :xapi_configured_host
+
+      def forwarded_ports(machine)
+        cfg = machine.provider_config
+        machine.config.vm.networks.filter_map do |type, opts|
+          next unless type == :forwarded_port
+          next if opts[:id] == "ssh" && !cfg.forward_ssh_port
+          next if opts[:disabled]
+
+          Services::Tunnels::Forward.new(
+            id: opts[:id], host_ip: opts[:host_ip] || "127.0.0.1", host: opts[:host].to_i,
+            guest_ip: opts[:guest_ip] || "127.0.0.1", guest: opts[:guest].to_i,
+            configured_host: (opts[CONFIGURED_HOST] || opts[:host]).to_i, auto_correct: !!opts[:auto_correct]
+          )
+        end
+      end
+
+      # A random id for this Vagrant installation (machine and user), stored
+      # in the Vagrant home (~/.vagrant.d). Hostname and login name alone
+      # collide across containers, CI runners and machines with the same names.
+      CLIENT_ID_MUTEX = Mutex.new
+
+      def client_id(env)
+        path = data_home(env).join("client-id")
+        CLIENT_ID_MUTEX.synchronize do
+          existing = read_client_id(path)
+          return existing if existing
+
+          # Write a temp file and hard-link it into place: link fails when
+          # another process was first, and nobody ever sees a half file.
+          FileUtils.mkdir_p(path.dirname)
+          tmp = path.sub_ext(".#{Process.pid}.#{SecureRandom.hex(4)}.tmp")
+          File.write(tmp, SecureRandom.uuid)
+          begin
+            File.link(tmp, path)
+          rescue Errno::EEXIST
+            nil
+          ensure
+            FileUtils.rm_f(tmp)
+          end
+          read_client_id(path) || raise(Errors::ServiceFailed.new(:client_id_unreadable, path: path.to_s))
+        end
+      end
+
+      def read_client_id(path)
+        return nil unless path.file?
+
+        id = path.read.strip
+        id.empty? ? nil : id
+      end
+
+      def data_path(machine)
+        machine.data_dir
+      end
+
+      # VM UUIDs of all machines of this plugin in Vagrant's machine index
+      # (any project, any dotfile path, any of Extensions.provider_names).
+      def indexed_vm_ids(env)
+        ids = []
+        env.machine_index.each do |entry|
+          id = indexed_vm_id(entry)
+          ids << id if id
+        end
+        ids
+      rescue StandardError => e
+        LOGGER.warn("could not read Vagrant's machine index: #{e.message}")
+        ids || []
+      end
+
+      # The VM UUID of one index entry, or nil. An entry that cannot be read
+      # (e.g. during a parallel destroy) is skipped, not the ones after it:
+      # the caller keeps the NFS exports of every machine it gets.
+      def indexed_vm_id(entry)
+        return nil unless Extensions.provider?(entry.provider) && entry.local_data_path
+
+        id_file = Pathname.new(entry.local_data_path.to_s).join("machines", entry.name.to_s, entry.provider.to_s, "id")
+        id = id_file.file? ? id_file.read.strip : ""
+        id.empty? ? nil : id
+      rescue StandardError => e
+        LOGGER.warn("could not read the id of machine #{entry.name}: #{e.message}")
+        nil
+      end
+
+      # Our directory in the Vagrant home (~/.vagrant.d/data/vagrant-xapi).
+      def data_home(env)
+        Pathname.new(env.home_path.to_s).join("data", "vagrant-xapi")
+      end
+
+      # qcow2 -> VHD with qemu-img (argv array, no shell), for hosts that
+      # cannot import qcow2.
+      def convert_qcow2(src, dst)
+        raise Services::Error.new(:qemu_img_missing) unless Vagrant::Util::Which.which("qemu-img")
+
+        result = Vagrant::Util::Subprocess.execute(
+          # -f qcow2: never let qemu-img guess the input format.
+          "qemu-img", "convert", "-f", "qcow2", "-O", "vpc", "-o", "subformat=dynamic", src.to_s, dst.to_s
+        )
+        return if result.exit_code.zero?
+
+        raise Services::Error.new(:qemu_img_failed, detail: result.stderr.to_s.strip[0, 500])
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/legacy/plugin.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Temporary: a stand-in for XenApi::Client, the client of the `xenapi` gem
+# that vagrant-xenserver brought along, so triggers in Vagrantfiles written
+# for it that `require "xenapi"` keep working for now (xenapi.rb, loaded
+# through lib/xenapi.rb). It says so once per run when a trigger uses it.
+#
+# Only this directory, lib/xenapi.rb and locales/legacy.en.yml belong to it;
+# docs/architecture.md section 17 lists what to delete to remove it. The
+# compatibility with vagrant-xenserver itself (lib/vagrant-xapi/xenserver)
+# is permanent and does not depend on it.
+
+require "pathname"
+
+require_relative "../extensions"
+
+module VagrantPlugins
+  module Xapi
+    module Legacy
+      # Port, timeout and TLS settings per host, from the provider configs of
+      # this run, for XenApi::Client, which only gets a URI.
+      def self.connections
+        @connections ||= {}
+      end
+
+      def self.remember(config)
+        return if config.host.nil? || config.host.to_s.empty?
+
+        ca_file = config.tls_ca_file && File.expand_path(config.tls_ca_file.to_s, project_root)
+        connections[config.host.to_s] = {
+          port: config.port, api_timeout: config.api_timeout,
+          tls: { verify: true, ca_file: ca_file, fingerprint: config.tls_fingerprint }.compact
+        }
+      end
+
+      # The project root as Vagrant finds it (the directory of the
+      # Vagrantfile, from VAGRANT_CWD or upwards from the current one), so a
+      # relative tls_ca_file means the same as for the provider.
+      def self.project_root
+        name = ENV["VAGRANT_VAGRANTFILE"].to_s.empty? ? "Vagrantfile" : ENV["VAGRANT_VAGRANTFILE"]
+        dir = Pathname.new(File.expand_path(ENV["VAGRANT_CWD"].to_s.empty? ? Dir.pwd : ENV["VAGRANT_CWD"]))
+        dir.ascend { |d| return d.to_s if d.join(name).file? }
+        Dir.pwd
+      end
+
+      # Once per process, the first time a trigger creates a XenApi::Client.
+      # Straight to stderr: Kernel#warn prints nothing when Ruby runs without
+      # warnings ($VERBOSE nil), as Vagrant's installer does.
+      def self.xenapi_notice
+        return if @noticed
+
+        @noticed = true
+        $stderr.puts I18n.t("vagrant_xapi.legacy.xenapi_notice")
+      end
+    end
+
+    Extensions.on_config_finalized { |config| Legacy.remember(config) }
+
+    I18n.load_path << File.expand_path("../../../locales/legacy.en.yml", __dir__)
+  end
+end

data/lib/vagrant-xapi/legacy/xenapi.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "uri"
+
+require_relative "../api/client"
+require_relative "plugin"
+
+# Temporary: a stand-in for the client of the `xenapi` gem that
+# vagrant-xenserver brought along, so triggers in Vagrantfiles written for it
+# keep working (see legacy/plugin.rb). It says once per run that it is
+# temporary.
+#
+#   xc = XenApi::Client.new("https://host:443/", 60)
+#   xc.login_with_password(user, password)
+#   xc.VM.get_VBDs(vm)            # any XAPI call: xc.<Class>.<method>(...)
+#   xc.session.logout
+#
+#
+# It runs on vagrant-xapi's own client: always HTTPS, with the port and TLS
+# settings of the provider config for that host (or VAGRANT_XAPI_TLS_*),
+# its own session, and HOST_IS_SLAVE handling. XAPI errors become
+# XenApi::Errors::<CamelCaseCode> (all StandardError).
+#
+# Machine ids of vagrant-xapi are VM UUIDs, where vagrant-xenserver used the
+# OpaqueRef. A UUID is passed on as it is, so XAPI answers HANDLE_INVALID to
+# code that uses machine.id as a reference; trigger code written for
+# vagrant-xenserver then falls back to looking the VM up by name. Turning the
+# UUID into a ref here would not be enough: such code also puts it into
+# records and compares it with refs XAPI returns.
+module XenApi
+  module Errors
+    class GenericError < StandardError
+      attr_reader :code, :params
+
+      def initialize(code = "INTERNAL_ERROR", params = [])
+        @code = code.to_s
+        @params = Array(params)
+        super([@code, *@params].join(" "))
+      end
+    end
+
+    def self.class_for(code)
+      name = code.to_s.downcase.split(/[^a-z0-9]+/).map(&:capitalize).join
+      return GenericError unless name.match?(/\A[A-Z][A-Za-z0-9]*\z/)
+      return const_get(name, false) if const_defined?(name, false)
+
+      const_set(name, Class.new(GenericError))
+    end
+
+    # The ones code written for vagrant-xenserver may rescue by name.
+    class_for("SESSION_AUTHENTICATION_FAILED")
+    class_for("HANDLE_INVALID")
+  end
+
+  class Client
+    # One namespace of calls: xc.VM, xc.pool, xc.session, ... A BasicObject,
+    # so that calls named like methods of Object (VM.clone, VM.hash) reach
+    # XAPI too.
+    class Namespace < BasicObject
+      def initialize(client, klass)
+        @client = client
+        @klass = klass
+      end
+
+      def method_missing(name, *args)
+        @client.call("#{@klass}.#{name}", *args)
+      end
+
+      def respond_to_missing?(*)
+        true
+      end
+    end
+
+    def initialize(uri, timeout = 60, *_rest)
+      VagrantPlugins::Xapi::Legacy.xenapi_notice
+      @host = URI(uri.to_s).host
+      @settings = connection_settings(@host, timeout)
+    end
+
+    def login_with_password(username, password, *_rest)
+      @client = VagrantPlugins::Xapi::Api::Client.new(
+        host: @host, port: @settings[:port], username: username, password: password,
+        tls: @settings[:tls], api_timeout: @settings[:api_timeout]
+      )
+      translate_errors { @client.login.session_ref }
+    end
+
+    def call(method, *args)
+      raise Errors::GenericError.new("SESSION_INVALID", ["not logged in"]) unless @client
+      return logout if method == "session.logout"
+
+      translate_errors { @client.call(method, *args) }
+    end
+
+    def logout
+      @client&.logout
+      ""
+    end
+
+    def method_missing(name, *args)
+      return super unless args.empty? && name.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+
+      Namespace.new(self, name.to_s)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/) || super
+    end
+
+    private
+
+    def connection_settings(host, timeout)
+      known = VagrantPlugins::Xapi::Legacy.connections[host.to_s]
+      return known if known
+
+      env = ->(name) { ENV[name].to_s.empty? ? nil : ENV[name] }
+      ca_file = env.call("VAGRANT_XAPI_TLS_CA_FILE")
+      { port: 443, api_timeout: timeout.to_i.positive? ? timeout.to_i : 60,
+        tls: { verify: true, ca_file: ca_file && File.expand_path(ca_file),
+               fingerprint: env.call("VAGRANT_XAPI_TLS_FINGERPRINT") }.compact }
+    end
+
+    def translate_errors
+      yield
+    rescue VagrantPlugins::Xapi::Api::XapiError => e
+      raise Errors.class_for(e.code).new(e.code, e.params)
+    end
+  end
+end

data/lib/vagrant-xapi/plugin.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The vagrant-xapi plugin must be run within Vagrant."
+end
+
+require_relative "extensions"
+
+module VagrantPlugins
+  module Xapi
+    # Registrations only; every component is loaded lazily in its block, so
+    # this file always loads.
+    class Plugin < Vagrant.plugin("2")
+      name "xapi"
+      description <<~DESC
+        Manages VMs on XenServer 8 and XCP-ng through XAPI.
+      DESC
+
+      # Only chosen when a Vagrantfile configures :xapi or --provider=xapi
+      # is given; it never becomes the default by accident.
+      provider(:xapi, parallel: true, defaultable: false, priority: 5,
+                      box_format: %w[xapi xenserver libvirt]) do
+        require_relative "provider"
+        Provider
+      end
+
+      config(:xapi, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      CAPABILITIES = %i[snapshot_list forwarded_ports public_address nic_mac_addresses configure_disks
+                        cleanup_disks validate_disk_ext default_disk_exts set_default_disk_ext].freeze
+
+      CAPABILITIES.each do |cap|
+        provider_capability(:xapi, cap) do
+          require_relative "cap"
+          Cap
+        end
+      end
+
+      command("xapi", primary: false) do
+        require_relative "command/root"
+        Command::Root
+      end
+    end
+  end
+end
+
+# Compatibility with Vagrantfiles of vagrant-xenserver (provider :xenserver).
+require_relative "xenserver/plugin"
+
+# Temporary: the XenApi::Client stand-in for triggers in those Vagrantfiles.
+# To remove it, delete this line and lib/vagrant-xapi/legacy (see
+# docs/architecture.md, section 17).
+require_relative "legacy/plugin"