vagrant-xapi 0.0.1 → 1.0.0

data/lib/vagrant-xapi/provider.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "log4r"
+require "vagrant"
+
+require_relative "action"
+require_relative "errors"
+require_relative "extensions"
+require_relative "glue"
+require_relative "services/power"
+require_relative "services/lookup"
+
+module VagrantPlugins
+  module Xapi
+    class Provider < Vagrant.plugin("2", :provider)
+      SAFE_HOST = /\A[A-Za-z0-9.:\-\[\]]+\z/.freeze
+      SAFE_USER = /\A[A-Za-z0-9._\-]+\z/.freeze
+
+      # Default synced folder types, in this order, when the Vagrantfile does
+      # not choose (config.vm.allowed_synced_folder_types).
+      SYNCED_FOLDER_TYPES = %i[rsync nfs smb].freeze
+
+      def initialize(machine)
+        super
+        @machine = machine
+        @logger = Log4r::Logger.new("vagrantplugins::xapi_provider")
+        prefer_rsync
+      end
+
+      def action(name)
+        method = "action_#{name}"
+        return Action.public_send(method) if Action.respond_to?(method)
+
+        nil
+      end
+
+      # The machine id is the VM UUID. A VM that cannot be found is
+      # :not_created, which makes Vagrant clear the data_dir. An id that is
+      # not a UUID goes to the extensions first (Extensions.on_foreign_id).
+      def state
+        return not_created if @machine.id.nil?
+
+        ctx = Glue.context(@machine)
+        unless Services::Lookup.uuid?(@machine.id)
+          Errors.wrap { Extensions.resolve_foreign_id(@machine, ctx) }
+          return not_created if @machine.id.nil?
+        end
+        info = Errors.wrap do
+          ref = Services::Lookup.new(ctx).vm_by_uuid(@machine.id)
+          ref ? Services::Power.new(ctx).state(ref) : nil
+        end
+        return not_created unless info
+
+        id = info[:state]
+        short = I18n.t("vagrant_xapi.states.short_#{id}", default: id.to_s)
+        long = I18n.t("vagrant_xapi.states.long_#{id}", default: short)
+        unless info[:operations].empty?
+          long = "#{long}\n\n#{I18n.t("vagrant_xapi.states.operations", operations: info[:operations].join(", "))}"
+        end
+        Vagrant::MachineState.new(id, short, long)
+      end
+
+      # nil until the guest has an IP.
+      def ssh_info
+        return nil if @machine.id.nil?
+
+        ctx = Glue.context(@machine)
+        Errors.wrap do
+          ref = Services::Lookup.new(ctx).vm_by_uuid(@machine.id)
+          return nil unless ref
+          return nil unless ctx.client.call("VM.get_power_state", ref) == "Running"
+
+          found = Glue.ip_detector(@machine, ctx).detect(ref)
+          return nil unless found
+
+          info = { host: found.first, port: @machine.config.ssh.guest_port || 22 }
+          proxy = proxy_command(ctx, ref)
+          info[:proxy_command] = proxy if proxy
+          info
+        end
+      end
+
+      # Nothing to install locally: the plugin talks to XAPI over HTTPS.
+      def self.usable?(_raise_error = false)
+        true
+      end
+
+      def self.installed?
+        true
+      end
+
+      def machine_id_changed; end
+
+      def to_s
+        id = @machine.id ? @machine.id.to_s : "new VM"
+        "XAPI (#{id})"
+      end
+
+      private
+
+      # The VM runs on a remote hypervisor. Without a choice in the
+      # Vagrantfile, Vagrant takes the usable type with the highest priority,
+      # which on macOS and Windows is SMB: it asks for credentials on every
+      # `up` (failing without a terminal) and needs the guest to reach this
+      # machine. rsync needs neither, so it comes first. Only the default
+      # changes: a folder with an explicit type keeps it.
+      def prefer_rsync
+        vm = @machine.config&.vm
+        vm.allowed_synced_folder_types ||= SYNCED_FOLDER_TYPES.dup if vm
+      end
+
+      def not_created
+        Vagrant::MachineState.new(:not_created,
+                                  I18n.t("vagrant_xapi.states.short_not_created"),
+                                  I18n.t("vagrant_xapi.states.long_not_created"))
+      end
+
+      # ProxyCommand through dom0 of the host the VM runs on, with normal
+      # host key checking (the old plugin turned it off).
+      def proxy_command(ctx, ref)
+        cfg = @machine.provider_config
+        return nil unless cfg.ssh_via_host
+
+        host = ctx.client.call("VM.get_resident_on", ref)
+        address = ctx.client.call("host.get_address", host)
+        user = cfg.host_ssh_user.to_s
+        unless SAFE_HOST.match?(address.to_s) && SAFE_USER.match?(user)
+          raise Errors::ServiceFailed.new(:unsafe_proxy, address: address.to_s, user: user)
+        end
+
+        "ssh -W %h:%p -l #{user} -o BatchMode=yes #{address}"
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/services/adoption.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module VagrantPlugins
+  module Xapi
+    module Services
+      # Hands an existing VM to a Vagrant machine: the VM gets the machine's
+      # marking, and its own disks are marked as the VM's, so that
+      # `vagrant destroy` removes them.
+      class Adoption
+        def initialize(ctx)
+          @client = ctx.client
+        end
+
+        # Replaces any older marking of the VM with this one and tags it. Its
+        # vTPM no longer counts as made by the plugin, so turning `vtpm` off
+        # does not remove it.
+        def mark_vm(vm, marking)
+          begin
+            @client.call("VM.remove_from_other_config", vm, Marking::VTPM)
+          rescue Api::XapiError
+            nil
+          end
+          marking.each do |key, value|
+            begin
+              @client.call("VM.remove_from_other_config", vm, key)
+            rescue Api::XapiError
+              nil
+            end
+            @client.call("VM.add_to_other_config", vm, key, value)
+          end
+          tags = @client.call("VM.get_record", vm)["tags"] || []
+          @client.call("VM.add_tags", vm, Marking::TAG) unless tags.include?(Marking::TAG)
+        end
+
+        # Marks the VM's exclusive disks (Disk VBDs whose VDI is not sharable
+        # and attached to no other VM) as its own. A disk that is not
+        # exclusive (any more) loses the VM's marking, so `vagrant destroy`
+        # never deletes it.
+        def mark_disks(vm)
+          vm_uuid = @client.call("VM.get_uuid", vm)
+          @client.call("VM.get_VBDs", vm).each do |vbd|
+            rec = @client.call("VBD.get_record", vbd)
+            vdi = rec["VDI"].to_s
+            next if rec["type"] != "Disk" || vdi.empty? || vdi == "OpaqueRef:NULL"
+
+            if exclusive_disk?(vdi, vm)
+              remove_owner(vdi)
+              @client.call("VDI.add_to_other_config", vdi, Marking::OWNER_VM, vm_uuid)
+            elsif @client.call("VDI.get_other_config", vdi)[Marking::OWNER_VM] == vm_uuid
+              remove_owner(vdi)
+            end
+          end
+        end
+
+        private
+
+        def exclusive_disk?(vdi, vm)
+          return false if @client.call("VDI.get_sharable", vdi)
+
+          @client.call("VDI.get_VBDs", vdi).all? { |vbd| @client.call("VBD.get_VM", vbd) == vm }
+        end
+
+        def remove_owner(vdi)
+          @client.call("VDI.remove_from_other_config", vdi, Marking::OWNER_VM)
+        rescue Api::XapiError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/services/base.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "socket"
+require "etc"
+
+require_relative "../api/errors"
+require_relative "../version"
+
+module VagrantPlugins
+  module Xapi
+    module Services
+      # A service-level error. `key` is a message key under
+      # vagrant_xapi.errors in locales/en.yml; the integration layer turns it
+      # into a Vagrant error with readable text.
+      class Error < StandardError
+        attr_reader :key, :params
+
+        def initialize(key, **params)
+          @key = key.to_sym
+          @params = params
+          super("#{key} #{params.inspect}")
+        end
+      end
+
+      # Everything a service needs to talk to the pool and the user.
+      #
+      # ui responds to:
+      #   info(key, **params), detail(key, **params), warn(key, **params),
+      #   progress(key, done, total, **params), clear_progress
+      # cancel: a callable returning true once the user pressed Ctrl-C.
+      Context = Struct.new(:client, :ui, :cancel, :logger, keyword_init: true) do
+        def cancelled?
+          cancel ? cancel.call : false
+        end
+
+        def progress_proc(key, **params)
+          return nil unless ui
+
+          ->(done, total = 1.0) { ui.progress(key, done, total, **params) }
+        end
+
+        # For XAPI task progress (0.0..1.0).
+        def task_progress(key, **params)
+          return nil unless ui
+
+          ->(fraction) { ui.progress(key, (fraction * 100).round, 100, **params) }
+        end
+
+        def run_task(method, *args, label: nil, progress_key: nil, timeout: nil, **params)
+          result = client.run_task(method, *args,
+                                   label: label || method,
+                                   timeout: timeout,
+                                   progress: progress_key ? task_progress(progress_key, **params) : nil,
+                                   cancel: cancel)
+          ui&.clear_progress if progress_key
+          result
+        rescue StandardError
+          ui&.clear_progress if progress_key
+          raise
+        end
+      end
+
+      # Small XAPI helpers shared by the services. Expects @client.
+      module Helpers
+        NULL_REF = "OpaqueRef:NULL"
+
+        # Also usable without including Helpers (commands).
+        def self.null_ref?(ref)
+          ref.nil? || ref.to_s.empty? || ref.to_s == NULL_REF
+        end
+
+        def null_ref?(ref)
+          Helpers.null_ref?(ref)
+        end
+
+        # Sets one other_config key (XAPI has no "set key", only add/remove).
+        def set_oc(klass, ref, key, value)
+          remove_oc(klass, ref, key)
+          @client.call("#{klass}.add_to_other_config", ref, key, value.to_s)
+        end
+
+        def remove_oc(klass, ref, key)
+          @client.call("#{klass}.remove_from_other_config", ref, key)
+        rescue Api::XapiError
+          nil
+        end
+
+        # [[vbd_ref, vbd_record], ...] for a VM
+        def vbds_of(vm)
+          @client.call("VM.get_VBDs", vm).map { |vbd| [vbd, @client.call("VBD.get_record", vbd)] }
+        end
+
+        # VDI refs of the VM's Disk VBDs
+        def disk_vdis(vm)
+          vbds_of(vm).filter_map do |_vbd, rec|
+            next if rec["type"] != "Disk" || null_ref?(rec["VDI"])
+
+            rec["VDI"]
+          end
+        end
+
+        def ignore_missing
+          yield
+        rescue Api::XapiError => e
+          raise unless %w[HANDLE_INVALID UUID_INVALID].include?(e.code)
+
+          nil
+        end
+
+        # A new, empty VDI; every VDI the plugin creates comes from here.
+        def create_vdi(sr, name, size, description:, read_only: false, type: "user", other_config: {}, tags: [])
+          @client.call("VDI.create", {
+            "name_label" => name, "name_description" => description, "SR" => sr,
+            "virtual_size" => size.to_i, "type" => type, "sharable" => false, "read_only" => read_only,
+            "other_config" => other_config, "xenstore_data" => {}, "sm_config" => {}, "tags" => tags
+          })
+        end
+
+        # Device slots in which a guest sees a CD drive. Xen emulates four IDE
+        # devices for an HVM guest, in slots 0-3. XAPI accepts a CD drive in a
+        # later slot, but the guest never sees it: its PV drivers leave CD
+        # drives to the emulation.
+        CD_SLOTS = %w[0 1 2 3].freeze
+
+        # A VBD on the VM's first free device; a CD only in a CD slot.
+        def create_vbd(vm, vdi, mode:, type:, other_config: {})
+          allowed = @client.call("VM.get_allowed_VBD_devices", vm).map(&:to_s)
+          if type == "CD"
+            allowed &= CD_SLOTS
+            raise Error.new(:no_free_cd_slot, in_use: cd_slots_in_use(vm)) if allowed.empty?
+          end
+          raise Error.new(:no_free_device) if allowed.empty?
+
+          @client.call("VBD.create", {
+            "VM" => vm, "VDI" => vdi, "userdevice" => allowed.first, "bootable" => false,
+            "mode" => mode, "type" => type, "unpluggable" => true, "empty" => false,
+            "other_config" => other_config, "qos_algorithm_type" => "", "qos_algorithm_params" => {}
+          })
+        end
+
+        # "0: Disk, 3: CD (empty)": what takes the CD slots, for messages.
+        def cd_slots_in_use(vm)
+          vbds_of(vm).map { |_vbd, rec| [rec["userdevice"].to_s, rec] }
+                     .select { |slot, _rec| CD_SLOTS.include?(slot) }
+                     .sort_by { |slot, _rec| slot.to_i }
+                     .map { |slot, rec| "#{slot}: #{rec["type"]}#{" (empty)" if null_ref?(rec["VDI"])}" }
+                     .join(", ")
+        end
+
+        # A string literal for the expressions of get_all_records_where. Block
+        # form: in a replacement string "\\" would mean one backslash.
+        def self.where_value(value)
+          value.to_s.gsub("\\") { "\\\\" }.gsub('"') { '\\"' }
+        end
+      end
+
+      # Markings put on every object the plugin creates. Cleanup only ever
+      # touches objects that carry them.
+      module Marking
+        PREFIX = "vagrant-xapi."
+        TAG = "vagrant"
+
+        # VM keys
+        MACHINE = "#{PREFIX}machine"
+        PROJECT = "#{PREFIX}project"
+        USER = "#{PREFIX}user"
+        CLIENT = "#{PREFIX}client"
+        CLIENT_ID = "#{PREFIX}client_id"
+        VERSION_KEY = "#{PREFIX}version"
+        TEMPLATE_UUID = "#{PREFIX}template"
+        # The plugin created the VM's vTPM (provider option `vtpm`), so it may
+        # remove it again when the option is turned off.
+        VTPM = "#{PREFIX}vtpm"
+
+        # Template keys
+        BOX = "#{PREFIX}box"
+        BOX_VERSION = "#{PREFIX}box_version"
+        BOX_PROVIDER = "#{PREFIX}box_provider"
+        BOX_DIGEST = "#{PREFIX}box_digest"
+        SR = "#{PREFIX}sr"
+        TEMPLATE_KEYS = [BOX, BOX_VERSION, BOX_PROVIDER, BOX_DIGEST, SR].freeze
+
+        # VDI keys
+        OWNER_VM = "#{PREFIX}vm"
+        DISK_NAME = "#{PREFIX}disk"
+        CLOUD_INIT = "#{PREFIX}cloud_init"
+        CONTENT_SHA256 = "#{PREFIX}sha256"
+        OF_TEMPLATE = "#{PREFIX}of_template"
+
+        # VBD key: CD drive for an ISO from an ISO SR (provider option `isos`)
+        ISO = "#{PREFIX}iso"
+
+        # VDI and VBD key: throwaway snapshot disk of `vagrant xapi diff`
+        # (value: the id of the run)
+        DIFF = "#{PREFIX}diff"
+
+        # Snapshot key
+        SNAPSHOT_OF = "#{PREFIX}snapshot_of"
+
+        # Network keys
+        NETWORK = "#{PREFIX}network"
+
+        module_function
+
+        def user
+          Etc.getlogin || ENV["USER"] || ENV["USERNAME"] || "unknown"
+        rescue StandardError
+          ENV["USER"] || "unknown"
+        end
+
+        def client_host
+          Socket.gethostname
+        rescue StandardError
+          "unknown"
+        end
+
+        # @param machine_name [String] Vagrant machine name
+        # @param project [String] path of the Vagrantfile directory
+        def vm_marking(machine_name:, project:, client_id: nil)
+          marking = {
+            MACHINE => machine_name.to_s,
+            PROJECT => project.to_s,
+            USER => user,
+            CLIENT => client_host,
+            VERSION_KEY => Xapi::VERSION
+          }
+          marking[CLIENT_ID] = client_id.to_s if client_id
+          marking
+        end
+
+        def marked?(other_config)
+          oc = other_config || {}
+          oc.key?(MACHINE) && oc.key?(PROJECT)
+        end
+
+        def ours?(other_config, key, value)
+          (other_config || {})[key].to_s == value.to_s && !value.to_s.empty?
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/services/box_source.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "pathname"
+require "securerandom"
+
+require_relative "base"
+require_relative "disk_image"
+
+module VagrantPlugins
+  module Xapi
+    module Services
+      # Describes what to import for a box: an XVA, an XVA URL, or one or more
+      # disk images. Understands three box providers: xapi, xenserver (boxes of
+      # the old vagrant-xenserver plugin) and libvirt.
+      class BoxSource
+        SUPPORTED_PROVIDERS = %w[xapi xenserver libvirt].freeze
+        DISK_FORMATS = %w[vhd qcow2 raw img].freeze
+
+        Disk = Struct.new(:path, :format, :virtual_size, keyword_init: true)
+
+        attr_reader :name, :version, :provider, :kind, :xva_path, :xva_url, :disks, :directory
+
+        # @param directory [Pathname] unpacked box directory
+        # @param xva_url [String, nil] from provider config (xapi or xenserver)
+        def initialize(name:, version:, provider:, directory:, xva_url: nil)
+          @name = name.to_s
+          @version = version.to_s
+          @provider = provider.to_s
+          @directory = Pathname.new(directory.to_s)
+          @xva_url_config = xva_url
+          @disks = []
+          raise Error.new(:box_provider_unsupported, provider: @provider) unless SUPPORTED_PROVIDERS.include?(@provider)
+
+          detect
+        end
+
+        def metadata
+          @metadata ||= begin
+            path = @directory.join("metadata.json")
+            path.file? ? JSON.parse(path.read) : {}
+          rescue JSON::ParserError
+            raise Error.new(:box_metadata_invalid, path: path.to_s)
+          end
+        end
+
+        def architecture
+          metadata["architecture"]
+        end
+
+        # Files that make up the box content, in import order.
+        def content_files
+          case @kind
+          when :xva then [@xva_path]
+          when :disks then @disks.map(&:path)
+          else []
+          end
+        end
+
+        # SHA-256 identifying the box content (cached on disk).
+        def digest(cache)
+          return Digest::SHA256.hexdigest("xva_url:#{@xva_url}") if @kind == :xva_url
+
+          files = content_files
+          return cache.digest(files.first) if files.size == 1
+
+          Digest::SHA256.hexdigest(files.map { |f| cache.digest(f) }.join(":"))
+        end
+
+        def description
+          case @kind
+          when :xva then "XVA #{File.basename(@xva_path)}"
+          when :xva_url then "XVA from #{@xva_url}"
+          else @disks.map { |d| "#{File.basename(d.path)} (#{d.format})" }.join(", ")
+          end
+        end
+
+        private
+
+        def detect
+          case @provider
+          when "xapi" then detect_xapi
+          when "xenserver" then detect_xenserver
+          when "libvirt" then detect_libvirt
+          end
+        end
+
+        def detect_xapi
+          format = metadata["format"].to_s
+          if format.empty?
+            # Tolerate boxes without format: look for a box.* file.
+            found = %w[xva vhd qcow2 raw img].find { |f| @directory.join("box.#{f}").file? }
+            return use_xva_url_or_fail if found.nil?
+
+            format = found
+          end
+          case format
+          when "xva"
+            use_xva(@directory.join("box.xva"))
+          when "vhd", "qcow2", "raw", "img"
+            use_disk(@directory.join("box.#{format}"))
+          else
+            raise Error.new(:box_format_unsupported, image_format: format)
+          end
+        end
+
+        def detect_xenserver
+          if @directory.join("box.xva").file?
+            use_xva(@directory.join("box.xva"))
+          elsif @directory.join("box.vhd").file?
+            use_disk(@directory.join("box.vhd"))
+          else
+            use_xva_url_or_fail
+          end
+        end
+
+        def detect_libvirt
+          if metadata["disks"].is_a?(Array) && !metadata["disks"].empty?
+            metadata["disks"].each_with_index do |d, i|
+              path = d.is_a?(Hash) && d["path"] ? d["path"] : (i.zero? ? "box.img" : "box_#{i}.img")
+              use_disk(@directory.join(path.to_s))
+            end
+          else
+            use_disk(@directory.join("box.img"))
+          end
+        end
+
+        def use_xva(path)
+          @kind = :xva
+          @xva_path = inside_box!(path)
+        end
+
+        def use_xva_url_or_fail
+          url = @xva_url_config.to_s
+          raise Error.new(:box_empty, directory: @directory.to_s) if url.empty?
+
+          @kind = :xva_url
+          @xva_url = url
+        end
+
+        def use_disk(path)
+          real = inside_box!(path)
+          info = DiskImage.inspect_file(real)
+          @kind = :disks
+          @disks << Disk.new(path: real, format: info.format, virtual_size: info.virtual_size)
+        end
+
+        # Box content is not trusted: every file it names must be a regular
+        # file inside the box directory, also after following symlinks, so a
+        # box cannot make the plugin upload files from the local machine.
+        # @return [String] the resolved path
+        def inside_box!(path)
+          raise Error.new(:box_file_missing, path: path.to_s) unless File.file?(path.to_s)
+
+          real = File.realpath(path.to_s)
+          root = File.realpath(@directory.to_s)
+          unless real.start_with?(root + File::SEPARATOR) && File.file?(real)
+            raise Error.new(:box_path_outside, path: path.to_s, directory: @directory.to_s)
+          end
+
+          real
+        end
+      end
+
+      # SHA-256 digests of box files, cached on path, size and mtime in
+      # ~/.vagrant.d/data/vagrant-xapi/digests.json.
+      class DigestCache
+        # One mutex for all instances: parallel machines each build their own
+        # DigestCache for the same file.
+        MUTEX = Mutex.new
+
+        def initialize(path)
+          @path = Pathname.new(path.to_s)
+          @mutex = MUTEX
+        end
+
+        def digest(file)
+          stat = File.stat(file)
+          key = File.expand_path(file)
+          @mutex.synchronize do
+            entry = load[key]
+            if entry && entry["size"] == stat.size && entry["mtime"] == stat.mtime.to_i
+              return entry["sha256"]
+            end
+          end
+
+          sha = Digest::SHA256.file(file).hexdigest
+          @mutex.synchronize do
+            data = load
+            data[key] = { "size" => stat.size, "mtime" => stat.mtime.to_i, "sha256" => sha }
+            save(data)
+          end
+          sha
+        end
+
+        private
+
+        def load
+          return {} unless @path.file?
+
+          JSON.parse(@path.read)
+        rescue JSON::ParserError
+          {}
+        end
+
+        def save(data)
+          FileUtils.mkdir_p(@path.dirname)
+          # Unique per writer, so processes never rename each other's file.
+          tmp = @path.sub_ext(".#{Process.pid}.#{SecureRandom.hex(4)}.tmp")
+          File.write(tmp, JSON.pretty_generate(data))
+          File.rename(tmp, @path)
+        end
+      end
+    end
+  end
+end